1. java基本特性

1.1 java语言平台版本

J2SE(Java 2 Platform Standard Edition)标准版
是为开发普通桌面和商务应用程序提供的解决方案，该技术体系是其他两者的基础，可以完成一些桌面应用程序的开发。
J2ME(Java 2 Platform Micro Edition)小型版
是为开发移动设备和嵌入式设备(电器、机器人、机顶盒…)提供的解决方案。
J2EE(Java 2 Platform Enterprise Edition)企业版
是为开发企业环境下的应用程序提供的一套解决方案，该技术体系中包含的技术如 Servlet、Jsp等，主要针对于Web应用程序开发。

1.2 java语言特点

简单性 高性能 编译性 解释性 面向对象 分布式处理 健壮性 安全性
开源 跨平台
什么是跨平台性？
通过Java语言编写的应用程序在不同的系统平台上都可以运行。
原理是什么？
只要在需要运行java应用程序的操作系统上，先安装一个Java虚拟机(JVM Java Virtual Machine)即可。由JVM来负责Java程序在该系统中的运行。
因为有了JVM，所以同一个Java程序在三个不同的操作系统中都可以执行。这样就实现了Java程序的跨平台性。也称为Java具有良好的可移植性。

1.3 jdk

JDK是 Java 语言的软件开发工具包，主要用于移动设备、嵌入式设备上的java应用程序。JDK是整个java开发的核心。
它包含了:
1、 JAVA开发工具(jdk\bin)
2、 基础开发库(jdk\jre\lib\rt.jar)
3、 基础开发库的源码(jdk\src.zip)

1.4 运行 于工作原理

1.5 jdk jre jvm的关系

1 JDK–Java Development Kit是针对Java开发员的产品，是整个Java的核心，包括了Java运行环境JRE、Java工具和Java基础类库。
2 JRE–Java Runtime Environment是运行JAVA的运行时环境，包含JVM和Java核心类库。
3 JVM–Java Virtual Machine，Java虚拟机的缩写，是整个java实现跨平台的最核心的部分，能够运行以Java语言写作的软件程序。

2. 数据类型+运算符

2.1 标识符

可以简单的理解为一个名字。在Java中，我们需要标识代码的很多元素，包括类名、方法、字段、变量、包名等。我们选择的名称就称为标识符，并且遵循以下规则：
A. 标识符可以由字母、数字、下划线（_）、美元符（$）组成，但不能包含 @、%、空格等其它特殊字符。
B. 不能以数字开头。
C. 标识符是严格区分大小写的。
D. 标识符的命名最好能反映出其作用，做到见名知意。

2.2 关键字

在java语言中已经被赋予特定意义的一些单词一共有53个关键字。其中有两个保留字:const和goto。关键字不能被用作标识符

2.3 数据类型

public static void main(String[] args) {
System.out.println(“姓名：”);
String name= new Scanner(System.in).nextLine();

2.3.1 整数字面值是int类型

int a = 999999999;//错，右侧是int类型，但是超出范围

2.3.2 byte，short，char三种比int小的整数可以用范围内的值直接赋值

byte b=127;//对
byte b=128;//错，右面已经超过byte范围是int类型的数据

2.3.3 浮点数的字面值是double类型

double a=3.14;//对
float a=3.14;//错，右面是double，float是四字节double是八字节存不下

2.3.4 字面值后缀l f d

L –long 如：long a = 99999999999;//错，超出范围，解决方案加L
F –float 如：float a = 3.14;//错，右面是double类型，解决方案加F
D –double 如：double a=3;//错，右面是int，解决方案加D或者改成3.0

2.3.5 进制前缀

0x - 16进制
0 -8进制
\u -char类型，16进制

2.4 基本类型的数据转换

2.4.1 小到大(隐式转换)

Byte a=120;
int b=a;//直接转

2.4.2 大到小（显式转换）

需要强制类型转换
int xx = 356;
byte y=(byte) xx;
注意：小数转成整数，小数直接舍弃

2.5 运算规则

2.5.1 计算结果的数据类型，与最大类型一致

3/2 得1 ，而不是1.5，结果是int类型
3d/2 得1.5，相当于double/int，结果是double类型

2.5.2 byte,short,char三种比int小的整数，运算时会先自动转换成int

byte a=3;
byte b=4;
byte c=a+b;//错，运行时，byte会先自动转成int再运算，int+int还是int

2.5.3 整数运算溢出

整数运算，类似于一个中标，转到最大时，再转会回到最小。
计算：光速运行一年的长度是多少米
System.out.println(300000000606024365);
System.out.println(300000000l606024365);

2.5.4 浮点数运算不精确

java提供了解决方案，后面就会讲到。
System.out.println(1-0.8);
System.out.println(4.35*100);

2.5.5 浮点数的特殊值

Infinity 无穷大 3.14/0
Nan not a number 0/0.0

2.6 拓展

char 类型可以存储一个中文汉字，因为 Java 中使用的编码是 Unicode（不选择任何特定的编码，直接使用字符在字符集中的编号，这是统一的唯一方法），一个 char 类型占 2 个字节（16 比特），所以放一个中文是没问题的。

3 方法+流程控制+循环

3.1 运算符

3.1.1 练习平年闰年

package day0203_平年闰年; import java.util.Scanner; public class Test1 { public static void main(String[] args) { System.out.println("年号："); int y = new Scanner(System.in).nextInt(); String r="平年"; if(y%4==0){ if(y%100!=0){ r="闰年"; } } if(y%400==0){ r="闰年"; } 或者 if((y%4==0&&y%100!=0)||y%400==0){ r="闰年"; } System.out.println(y+"年是"+r); } }

3.1.2自增自减

int a = 1; System.out.println(a++);//先取值再自增 int b=1; System.out.println(++b);//先自增再取值

3.2 分支结构

switch(变量或者表达式){
case 1:
case 2:
case 3:
case 4:
default:
}

3.3 循环语句

for循环 从1打印到10

public class ttttt { public static void main(String[] args) { f1(); } public static void f1(){ for (int i = 0; i public static void main(String[] args) { // f1(); f2(); } //总结1：当i=1时，j取到了所有满足条件的数据，1,2,3,4,5。 //也就是说外循环执行1次，内循环执行多次 private static void f1() { for(int i=1;i//内循环 System.out.println("j="+j);//1,2,3,4,5 } } } //总结2：外循环控制行，内循环控制列 private static void f2() { for(int i=1;i System.out.print("*"); } System.out.println(); } } }

4.2 break和continue

用来终止循环
break:中断当前循环 简单粗暴
continue:跳出本次循环 进入下一轮

4.3 while 和do while循环

while 先判断再执行
do while 先执行 再判断 所以至少执行一次

4.4 变量

4.4.1 概念

可以改变的数，称为变量。一般通过三部分来描述一个变量。变量类型，变量名，变量值。其中三部分都是可以改变的，根据需要来确定即可。
变量的使用原则：就近原则。尽量控制到最小范围。。

4.4.2 局部变量

定义在方法里，或者局部代码块中。
注意：必须手动初始化，来分配内存。如：int i=5;
作用域也就是方法里或者局部代码块里，方法运行完内存就释放了。

4.4.3 成员变量

定义在类里。
注意：不用初始化，也会自动被初始化成默认值。
作用域是整个类中，类消失了，变量才释放。

4.5 拓展

4.5.1 三种循环的区别

三种循环都可以互相代替
1、 for：知道循环次数
2、 while/do while：当循环次数不确定时
3、 while：先判断，不符合规则，不执行代码
4、 do while：代码最少被执行一次，再去判断，符合规则，再次执行代码

5 数组+变量

5.1 方法

5.1.1 概述

被命名的代码块，方法可以含参数可以不含参数
可以提高代码的复用性

5.1.2 形式

修饰符 返回值 方法名(【参数】){
方法体;
}

5.1.3 方法的重载

方法重载是指在一个类中定义多个同名的方法,但要求每个方法具有不同的参数列表(也就是说参数的个数和类型不同)
程序调用方法时,可以通过传递给他们的不同个数和类型来决定具体使用那个方法

5.2 数组

5.2.1 概念

数组Array是用于储存多个相同类型的数据
想要获得数组中的元素值 可以通过元素的下标来获取 下标是从0开始的

5.2.2 创建数组

一般分为动态初始化和静态初始化
动态初始化 : int[] a=new int[5];
静态初始化1: int[]a={1,2,3,4,5};
静态初始化2: int[]a=new int[]{1,2,3,4,5};

5.2.3 数组的长度

length属性获取数组长度
数组一旦创建长度不可变
允许0长度的数组

5.3 数组的遍历

从头到尾 依次访问数组的位置
形式
for(int i=0:i //控制轮数 for(int j=0;j //每次都是和它下一个元素比 int t=arr[j]; arr[j]=arr[j+1]; arr[j+1]=t; } } }

6 面向对象

6.1 面向对象

6.1.1 概念

所谓的面向对象是一种编程思想,通过这种思想可以把生活中的复杂事情变得简单化,从原来的执行者变成指挥者,面向对象是基于面向过程而言的。我们经常说的面向对象的编程实现（OOP，Object Oriented Programming）
l 面向过程强调的是过程，例如：
1、打开冰箱 2、把大象放进去 3、关上冰箱
l 面向对象强调结果，例如：
1、 饿了，去平台点餐，这个动作就是面向对象。你没有去市场买菜洗菜做饭。。。只要有app就可以了。
2、 衣服脏了，直接甩给女票去处理等着穿干净的就可以了。你没有关注中间的过程。。只要找好对象就可以了。
3、面试官问什么是面向对象？你答万物皆对象！！不建议因为你还没到这个深度，最好举例。就像是，你说空即是色色即是空—信你个鬼。

6.1.2 三大特征

1.封装性.把相关的数据封装成一个 类 组件
2.继承性 是子类自动共享父类属性和方法,这是类之间的一种关系
3.多态,增强软件的灵活性和重用性

6.2 类和对象

6.2.1 类

1、 Java语言最基本单位就是类，类似于类型。
2、 类是一类事物的抽象。
3、 可以理解为模板或者设计图纸。

6.2.2 对象

每个对象具有三个特点：对象的状态，对象的行为和对象的标识。
1、 对象的状态用来描述对象的基本特征。
2、 对象的行为用来描述对象的功能。
3、 对象的标识是指对象在内存中都有一个唯一的地址用来和其他对象区分开来。
4、 类是一类事物的抽象，对象是具体的实现。

6.2.3类和对象的关系

1、 计算机语言是用来描述现实世界事物的。属性+行为
2、 那怎么通过java语言描述呢？通过类来描述事物，把事物的属性当做成员变量，把行为当做成员方法。

6.3类和对象的创建和使用

6.3.1类的创建和使用

通过class关键字创建类，通过new关键字创建对象。

```java public class Test1 { public static void main(String[] args) { //p是引用对象，持有了对于Person对象的地址值的引用 //此时的p，含有属性，但都是默认值 Person p = new Person(); //设置属性值 p.name="lisi"; p.age=20; //调用方法 p.eat(); p.sleep(); } } class Person{ //属性--成员变量 String name; int age; //行为--方法 void eat(){ System.out.println("吃饭饭"); } void sleep(){ System.out.println("睡觉觉"); } } ### 6.3.2 对象在内存中的储存 java把内存分为五大区域 我们重点关注栈和堆  1.一般来讲局部变量存在栈中,方法执行完毕内存就被释放 2.对象(new出来的东西)存在堆中,对象不再被使用时,内存才会被释放 3.每个堆内存中的元素都有地址值 4.对象中的属性都是有默认值的 ### 6.3.3单一对象内存图  1、 在栈内存中，创建一个引用变量p，持有对象的地址值 2、 在堆内存中，创建Person对象，并且开辟变量的空间，完成初始化 3、 给堆内存中的元素，分配一个唯一标志，地址值。交给p去保存。 4、 p.name=”lisi”;p.age=20;就去堆内存中找唯一的地址值，找到Person对象，并对其属性进行修改赋值。 5、 p.eat();就去堆内存中找唯一的地址值，找到Person对象，执行Person对象的方法。 ### 6.3.4多对象内存图  ## 6.4 封装 ### 6.4.1概念 封装是指隐藏对象的属性和实现细节，仅仅对外提供公共的访问方式。 好处： 1、 提高安全性 2、 提高重用性 案例： 1、 类 2、 方法 ### 6.4.2 private关键字 是一个权限修饰符，用于修饰成员变量和成员函数，被私有化的成员只能在本类中访问。 想要修改只能提供对外提供公共的，get和set方法。 ```java package day006; public class Student { //String name; //把属性隐藏起来 private String name; //提供公共的访问方法 //设置公共的赋值方法 public void setName(String n){ name=n; } //设置公共的取值方法 public String getName(){ return name; } int age; } class StDemo{ public static void main(String[] args) { Student s = new Student(); //不能访问私有的 //s.name="zhangsan"; //System.out.println(s.name);s //利用setXxx()给属性赋值 s.setName("zhangsan"); //利用getXxx()给属性取值 System.out.println(s.getName()); } }

7 面向对象2

1 构造方法

1.1概念

构造方法是一种特殊的方法，它是一个与类同名且返回值类型为同名类类型的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的创建或者对象的初始化。当类实例化一个对象时会自动调用构造方法。
构造方法和其他方法一样也可以重载。
形式
可以无参也可以有参
修饰符 类名(【参数】){
代码……
}

1.2练习

public class Test2_构造方法 { String name; //当存在一个含参的构造方法时，无参构造将不再自动生成... //public Test2_构造方法(){} //含参构造 public Test2_构造方法(String n){ name=n; } void eat(){ System.out.println("Test2_构造方法.eat()"); } } class tt{ public static void main(String[] args) { //注释掉无参的构造也可以运行，说明系统会自动提供一个无参的构造方法 Test2_构造方法 t2 = new Test2_构造方法(); t2.eat(); //t是引用变量，引用的是对象的地址值。 //根据地址值找到对象，并获取对象的数据 Test2_构造方法 t = new Test2_构造方法("张三"); System.out.println(t.name); } }

2 构造代码块和局部代码块

2.1 构造代码块

1、 在类的内部，方法外部，的代码块。
2、 通常用于抽取构造方法中的共性代码。
3、 每次调用构造方法前都会调用构造代码块
4、 优先于构造方法加载

class c{ String country; { country="中国"; } public c() { System.out.println("1号选手，来自"+country); } public c(int a) { System.out.println("2号选手，也来自"+country); } }

2.2 局部代码块

1、 在方法里面的代码块
2、 通常用于控制变量的作用范围，出了括号就失效
3、 变量的范围越小越好，成员变量会有线程安全问题
4、 总结：执行顺序：
构造代码块是最优先的，局部代码块顺序执行

3 this关键字

3.1概念

this代表本类对象的一个引用对象。
构造函数中，this()必须放在第一行。
形式
//name=name;
//age=age;
其实是想把Student类的局部变量name的值赋值给成员变量，相当于你想操作是这样的：
//Student.name=name;
但是你不能直接写类名，这时候就用代表本类的对象this来完成。代码变成了：
this.name=name;

3.2 练习 当变量名相同时

当局部变量和成员变量同名时，用于区分。
如果附近有同名变量，会遵从变量的就近原则，那么怎么调用成员变量呢？

package day99999; public class T { public static void main(String[] args) { Animal a = new Animal(); a.run("大黄"); System.out.println(a.name); } } class Animal{ String name; /* //当局部变量的名字和成员变量不一样时简单，拿着局部变量的值直接给成员变量赋值就行了 public void run(String n){ name=n; }*/ //问题来了，当局部变量和成员变量同名时呢？？ public void run(String name){ //name=name;//变量的就近使用原则,这样用的都是最近的也就是一直在用局部变量的 this.name=name;//this调用成员变量 } }

构造方法间的调用

package day99999; public class T { public static void main(String[] args) { Animal a = new Animal(); // Animal a2 = new Animal("旺财"); } } class Animal{ public Animal(){ this("来福");//调用本类中的含参构造 System.out.println(name); } public Animal(String name){ System.out.println(name); } }

4 继承

4.1概念

继承是面向对象最显著的一个特性。
继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。
Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类/超类/基类。
这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。
提高复用性：只要继承父类，就能有一样的功能

class A extends c{ //原来的eat()拿走了 } class B extends c{ //原来的eat()拿走了 } class c{ public void eat(){ syso("eat"); } }

4.2特点

1、 使用extends关键字
2、 相当于子类把父类的功能复制了一份
3、 java只支持单继承
4、 继承可以传递（爷爷，儿子，孙子的关系）
5、 不能继承父类的私有成员
6、 继承多用于功能的修改，子类可以拥有父类的功能的同时，进行功能拓展
7、 像是is a 的关系

package day99999; public class TTT { public static void main(String[] args) { Zi zi = new Zi(); zi.speak(); System.out.println(zi.skin); System.out.println(zi.addr); } } class Fu{ String skin="黄种人"; String addr="大成都" public void speak(){ System.out.println("Fu...speak()"); } } //通过extends和父类发生继承关系 //所有父类的功能，子类都可以继承过来，注意不能是private的 class Zi extends Fu{ //什么都不写，能不能把父亲的内容复制一份出来 }

5 super关键字

1、 通过super关键字可以使用父类的内容
2、 super代表父类的一个引用对象
3、 如果用，必须出现在调用位置的第一行

6 方法的重写

1、 继承后，子类就拥有了父类的功能
2、 那么在子类中，可以添加子类特有的功能也可以修改父类的原有功能
3、 子类中方法签名与父类完全一样(包括方法的返回值，方法名和参数列表，完全一致)时，会发生覆盖/复写操作，相当于修改功能
注意：
1、父类中的私有方法不能被重写
2、子类重写父类方法时，修饰符要大于等于父类修饰符的权限

7 继承中的使用

8.拓展

8.1 this和super的区别

1、 this代表本类对象的引用，super代表父类对象的引用。
2、 this用于区分局部变量和成员变量
3、 super用于区分本类变量和父类变量
4、 this.成员变量 this.成员方法() this(【参数】)代表调用本类内容
5、 super.成员变量 super.成员方法() super(【参数】)，代表调用父类内容
6、 this和super不可以同时出现在同一个构造方法里，他们两个只要出现都得放在第一行，同时出现的话，到底第一行放谁呢。。

8.2 重载和重写的区别

1、重载：是指同一个类中的多个方法具有相同的名字,但这些方法具有不同的参数列表,即参数的数量或参数类型不能完全相同
2、重写：是存在子父类之间的,子类定义的方法与父类中的方法具有相同的方法名字,相同的参数表和相同的返回类型
3、重写是父类与子类之间多态性的一种表现
4、重载是一类中多态性的一种表现

8.面向对象3

1static

1.1 概念

1、 是java中的一个关键字
2、 用于修饰成员（成员变量和成员方法）

1.2 特点

1、 可以修饰成员变量，成员方法
2、 随着类的加载而加载，优先于对象加载
3、 只加载一次，就会一直存在，不再开辟新空间
4、 全局唯一，全局共享
5、 可以直接被类名调用
6、 静态只能调用静态，非静态可以随意调用
7、 static不能和this或者super共用，因为有static时可能还没有对象

1.3入门案列

package cc; public class aa { public static void main(String[] args) { //特点2，优先于对象加载，有没有对象都有static int i = Student.age; System.out.println(i); //特点3,只加载一次，就会一直存在，不再开辟新空间 //创建对象 Student s = new Student(); Student s1 = new Student(); //调用方法 System.out.println(s.name); System.out.println(s.age); s.speak(); s.eat(); } } class Student{ String name="张三"; static int age=20; public void eat(){ System.out.println("eat.."); } public static void speak(){ System.out.println("speak..."); } }

1.4静态调用关系

静态只能调用静态（变量或者方法），非静态可以访问所有的不管是不是静态

package cc; public class O { public static void main(String[] args) { Teacher t = new Teacher(); t.speak(); } } class Teacher{ static int age=30; String name="王康"; //非静态测试 public void speak(){ System.out.println(age);//非静态能调用静态变量 System.out.println(name);//非静态能调用非静态变量 qiao();//非静态能调用静态方法 } //静态测试 public static void qiao(){ System.out.println(age);//静态能调用静态 // System.out.println(name);//静态不能调用非静态变量，只能调用静态变量 // speak();//静态不能调用非静态方法，只能调用静态方法 } }

2 静态代码块 构造代码块 局部代码块

2.1 静态代码块

随着类的加载而加载，并且只被加载一次，一般用于项目的初始化

2.2概述

1、 静态代码块：在类加载时就加载，并且只被加载一次，一般用于项目的初始化
2、 构造代码块：在调用构造方法前会自动调用，每次创建对象都会被调用
3、 局部代码块：方法里的代码块，方法被调用时才会执行
4、 静态代码块：static{ }，位置：在类里方法外
5、 TODO创建测试类，类中写好静态代码块，构造代码块，构造方法，普通方法里嵌套局部代码块。测试他们的执行顺序。
6、 静态 - 构造代码块 - 构造方法 - 局部

2.3测试

package cn.tedu.staticdemo; public class Test4 { public static void main(String[] args) { Car c = new Car();c.show(); Car c2 = new Car(); } } class Car{ //静态代码块 //1，在类第一次加载时就加载到内存中并一直驻存， //并全局共享,直到类消失静态资源才消失 //2，并且静态资源只被加载一次 static { System.out.println(1); } //构造代码块 { System.out.println(2); } // 构造方法 public Car() { System.out.println(3); } public void show() { // 局部代码块 { System.out.println(6); } System.out.println(4); System.out.println(5); } }

3 final

3.1概念

1、 是java提供的一个关键字
2、 final是最终的意思
3、 final可以修饰类，方法，成员变量
初衷是因为：java出现了继承后，子类可以更改父类的功能，当父类功能不许子类改变时可以利用final关键字修饰父类。

3.2 特点

1、 被final修饰的类，不能被继承
2、 被final修饰的方法，不能被重写
3、 被final修饰的变量是个常量，值不能被更改
4、 常量的定义形式： final 数据类型 常量名 = 值

4.多态

4.1概念

多态指同一个实体同时具有多种形式。它是面向对象程序设计（OOP）的一个重要特征。
主要是指同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。
好处是可以把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。
例如：水，在不同时刻可以有多种形态，包括水蒸气，冰，水。
Java怎么体现多态呢？狗有两种形态：狗和小动物
class Animal
class Dog extends Animal
Dog d = new Dog();//狗是狗
Animal a=new Dog();//狗是小动物，创建了狗的对象，赋值给动物对象，这就是多态

4.2特点

1、 多态的前提是继承
2、 要有方法的重写
3、 父类引用指向子类对象,如：Animal a = new Dog(); – 小到大，向上转型
4、 多态中，编译看左边，运行看右边

package cc; public class p { public static void main(String[] args) { /*Animal a = new Animal(); a.eat(); Dog d = new Dog(); d.kanjia(); d.eat();*/ //父类引用指向子类对象--把右面的小的，给了左面大的。相当于从小到大的过程，向上造型。 Animal an = new Dog(); an.eat();//只可以用父类的功能，这就统一了调用的标准 //狗吃肉,由于eat()发生了重写，所以父类方法被覆盖掉了 } } class Animal{ public void eat(){ System.out.println("大小通吃"); } } class Dog extends Animal{ public void kanjia(){ System.out.println("狗可以看家"); } public void eat(){ System.out.println("狗吃肉"); } }

4.3 多态的好处

1、 多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法。
2、 提高了程序的扩展性和可维护性

public class Q { public static void main(String[] args) { //多态--父类引用指向子类对象 Dog a2=new Dog(); Cat a2 = new Cat(); Animal2 a2 = new Dog(); eat(a2);//传入的参数满足条件就可以，运行右面的功能 } //封装共性方法，不关心具体类型，只要传入的参数是子类就可以 public static void eat(Animal2 a){ a.eat(); } }

5多态的使用

5.1特点

1、成员变量：使用的是父类的
2、成员方法：由于存在重写现象所以使用的是子类的
3、静态成员：随着对象而存在，谁调用的就返回谁的

6.拓展

6.1 静态代码块，构造代码块，局部代码块

！！！执行顺序：静态代码块—构造代码块—构造函数
7、 静态代码块：在类加载时就加载，并且只被加载一次，一般用于项目的初始化
8、 构造代码块：在创建对象时会自动调用，每次创建对象都会被调用
9、 局部代码块：方法里的代码块

9 面向对象4

1 异常

1.1概述

用来封装错误信息的对象。
组成结构：类型，提示，行号。

1.2异常的继承结构

Throwable - 顶级父类
– Error：系统错误，无法修复
– Exception：可修复的错误
–RunTimeException
–ClassCastException
–ClassNotFoundException

1.3异常的处理

程序中遇到了异常，通常有两种处理方式：捕获或者向上抛出。
当调用了一个抛出异常的方法时，调用位置可以不做处理继续向上抛出也可以捕获异常。
1、捕获方式：

try{
需要捕获的代码
}catch(异常类型 异常名){
处理方案
}

2、抛出方式：
在会发生异常的方法上添加代码：throws 异常类型
例如： public static void main(String[] args) throws Exception{

接收键盘输入的两个数字并做除法运算

package cn.tedu.exception; import java.util.Scanner; //测试异常的发生和解决 public class Test6_Exception { // 接收键盘输入的两个整数并做除法运算 public static void main(String[] args) { //1，捕获异常：把可能发生异常的代码放在try里， //当异常发生时会被catch住并执行catch中的代码执行异常处理的代码 try { int a = new Scanner(System.in).nextInt(); int b = new Scanner(System.in).nextInt(); System.out.println(a/b); } catch (Exception e) { //提出解决方案 System.out.println("您输入的两次整数有误！"); } } }

2 访问控制符

3 抽象类

3.1概念

Java中可以定义没有方法体的方法，该方法由其子类来具体的实现。该没有方法体的方法我们称之为抽象方法，含有抽象方法的类我们称之为抽象类。
抽象类可以理解为是一个只有方法声明没有方法体的特殊类。
举例：水果，东西。。
修饰符 abstract 返回值 方法名(参数列表);

class A{ public void eat(){//声明一样，可以提取 syso("eat...B") } } class B{ public void eat(){//声明一样，可以提取 syso("eat。。。A") } } abstract class C{ public abstract void eat(); }

3.2特点

1、 通过java关键字abstract实现
2、 可以修饰方法或者类
3、 抽象类中可以没有抽象方法（由子类去实现）
4、 如果类中有抽象方法，那该类必须定义为一个抽象类
5、 子类继承了抽象类以后，要么还是一个抽象类，要么就把所有抽象方法都重写
6、 多用于多态中
7、 抽象类不可以被实例化

3.3 入门案例

package day009; public class Test1_Animal { public void eat(){ System.out.println("吃饭饭"); } } class Dog extends Test1_Animal{ public void eat(){ System.out.println("狗吃肉"); } } class Cat extends Test1_Animal{ public void eat(){ System.out.println("猫吃鱼"); } }*/ //上面的eat()声明都一样，就是方法体不一样，那就只抽取方法声明部分。 //The type Animal must be an abstract class to define abstract methods abstract class Animal extends Object{ //This method requires a body instead of a semicolon public abstract void eat(); } //继承抽象类，并实现抽象方法 //The type Dog must implement the inherited abstract method Animal.eat() abstract class Dog extends Animal{ //可以实现抽象方法，也可以子类再变成一个抽象类 } class Cat extends Animal{ public void eat() { System.out.println("猫吃鱼"); } }

4 抽象类的用法

4.1构造函数

抽象类也有构造方法 但是不能本身实例化
那抽象类的构造函数有啥用?一般用于给子类实例化

package day009; //抽象类的构造方法 public class Test2_Animal2 { } abstract class Animal2{ //抽象类可以有构造方法，但是无法实例化 //用于子类实例化 public Animal2(){ System.out.println("fu..Animal2()"); } } class Zi2 extends Animal2{ } class TestAnimal2{ public static void main(String[] args) { // Animal2 a2 = new Animal2();//抽象类无法实例化 // Zi2 z=new Zi2();//创建子类实例化对象 Animal2 a2 = new Zi2();//抽象类多用于多态 } }

4.2 抽象类的成员变量 成员方法

既可以有变量，也可以有常量。
抽象类里，既可以有普通方法，有可以有抽象方法。

10 面向对象5

1 接口

1.1 概念

Java里面由于不允许多重继承，所以如果要实现多个类的功能，则可以通过实现多个接口来实现。
Java接口和Java抽象类代表的就是抽象类型，就是我们需要提出的抽象层的具体表现。OOP面向对象的编程，如果要提高程序的复用率，增加程序的可维护性，可扩展性，就必须是面向接口的编程，面向抽象的编程，正确地使用接口、抽象类这些太有用的抽象类型做为java结构层次上的顶层。
interface 接口名{ 代码… }

1.2 特点

1、 接口中都是抽象方法
2、 通过interface关键字创建接口
3、 通过implements让子类来实现
4、 可以理解成，接口是一个特殊的抽象类
5、 接口突破了java的单继承的局限性
6、 接口和类之间可以多实现，接口和接口之间可以多继承
7、 接口是对外暴露的规则，是一套开发规范
8、 接口提高了程序的功能扩展，降低了耦合性

1.3 入门案例

package day10; public class T { public static void main(String[] args) { Zi z = new Zi(); z.study(); z.teach(); } } interface Fu{ public abstract void study(); public abstract void teach(); } //实现+重写 class Zi implements Fu{ public void study(){ System.out.println("Zi..study()"); } public void teach(){ System.out.println("Zi..teach()"); } }

2 接口的用法

2.1 构造方法

接口里是没有构造方法的。
在创建实现类的对象时默认的super()，是调用的默认Object的无参构造。

interface Fu{//定义一个接口 public abstract void show(); //Interfaces cannot have constructors /*public Fu(){ System.out.println("Fu.Fu()"); }*/ }

2.2 成员变量

接口里没有成员变量，都是常量。所以，你定义一个变量没有写修饰符时，默认会加上：
public static final

package day10; //构造函数，成员方法，成员变量 public interface Test7_Fu { } interface Fu2{//定义一个接口 //int num=10;//1,成员变量 //static int num=10;//2,默认就是静态的 //final static int num=10;//3,默认就是final的 public final static int num=10;//4,默认就是public的 class Zi7 implements Fu2{ } class Test7Demoo{ public static void main(String[] args) { Zi7 z= new Zi7(); //The final field Fu2.num cannot be assigned //z.num=30;//默认是final的，不能修改值 System.out.println(z.num); System.out.println(Fu2.num); } }

2.3 成员的接口方法

接口里的方法，默认就都是抽象的，如果你不写明是abstract的，那会自动补齐。
例如：public abstract void save

3.接口的复杂用法

Java中单继承的局限性通过接口可以解决。
接口可以多继承也可以多实现，甚至可以继承的同时多实现。

4.总结

1、类和类的关系：继承 extends / 单继承 / 单根继承
– 继承的意义：为了提高代码的复用性，减少了代码的编写提高开发效率。
– 方法重写的意义：在不修改父类源码的前提下，在子类中重写业务，从此使用的就是重写后的功能。
– 要求子类的方法声明和父类一样，只要改方法体。
– 有了继承有了重写就产生了多态，多态的意义：为了统一程序的调用标准，标准就是父类。
– 多态 也就是向上转型/向上造型。
– 向下造型的意义：很少用，相当于想要使用子类的特殊功能，还不如直接创建子类对象简单。
– class A extends B
– 其中，A和B都是类，A是子类，B是父类，A就拥有了B的所有功能(除了私有的和构造方法)
– 其他知识点：this 和super ，构造方法，各种代码块…

2、类和接口关系：实现implements / 单实现 / 多实现
– class A implements B,C
– 其中，A是实现类,B和C是接口
– 要求A 可以把 B 和C 接口里的所有 抽象方法 都重写掉，否则 A 就是抽象类
– 接口不能创建对象
– 接口里没有构造方法，接口里都是常量，接口里都是抽象方法

3、接口和接口关系：继承extends / 单继承 / 多继承
– 接口的多继承的关系，打破了java单继承的局限性
– interface A extends B,C
– 其中，A B C 都是接口，A是子接口，同时拥有B和C接口里的所有功能
– class AImpl implements A
– 要求AImpl需要重写A接口里的所有方法(是包含B和C接口的所有方法)，否则就是抽象类

4、接口和抽象类的区别！！！
– 相同点：都是抽象层，都不能实例化
– 不同点：
– 1、抽象类用abstract关键字描述，接口用interface
– 2、子类和抽象类之间是extends关系，实现类和接口之间是implements关系
– 3、抽象类中 可以 有构造方法 ，接口里 不能 出现 构造方法
– 4、抽象类里可以有 变量，接口里没有变量全都是静态的常量
– 5、接口里定义常量的语法：public static final String NAME=“jack”，会为变量自动拼接public static final
– 6、抽象类里 可以有普通方法 也可以有 抽象方法，接口都是抽象方法
– 7、抽象类和子类之间是继承关系，而且java中，只支持单继承
– 8、接口突破了java单继承的局限性，因为接口可以多继承也可以多实现，甚至可以继承的同时多实现
– 9、接口的复杂用法
– 多继承： interface A extends B,C 其中A是子接口，同时拥有自己的和BC的功能
– 多实现： class AImpl implements M,N,O,P 其中AImpl是实现类，需要同时重写MNOP的所有抽象方法，否则就是一个抽象类
– 继承的同时多实现： class AImpl extends Object implements M,N 一定是先继承后实现

5.设计模式

Java中有23 种设计模式，本质是面向对象设计原则的实际运用，是对类的封装性、继承性和多态性，以及类的关联关系和组合关系的充分理解。

当然，软件设计模式只是一个引导，在实际的软件开发中，必须根据具体的需求来选择。
1、 对于简单的程序，可能写一个简单的算法要比引入某种设计模式更加容易。
2、 但是对于大型项目开发或者框架设计，用设计模式来组织代码显然更好。

5.1单例设计模式概念

单例模式可以说是大多数开发人员在实际中使用最多的，常见的Spring默认创建的bean就是单例模式的。
单例模式有很多好处，比如可节约系统内存空间，控制资源的使用。
其中单例模式最重要的是确保对象只有一个。
简单来说，保证一个类在内存中的对象就一个。
RunTime就是典型的单例设计，我们通过对RunTime类的分析，一窥究竟。

6 拓展

6.1 abstract注意事项

抽象方法要求子类继承后必须重写。那么，abstract关键字不可以和哪些关键字一起使用呢？以下关键字，在抽象类中。用是可以用的，只是没有意义了。
1、 private：被私有化后，子类无法重写，与abstract相违背。
2、 static：静态的，优先于对象存在。抽象方法需要子类重写，而静态的方法是无法被重写的，因此二者是矛盾的。
3、 final：被final修饰后，无法重写，与abstract相违背。

6.2 接口和抽象类的区别

1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。
2、抽象类要被子类继承，接口要被类实现。
3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现
4、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。
6、抽象方法只能申明，不能实现，接口是设计的结果 ，抽象类是重构的结果
7、抽象类里可以没有抽象方法，如果要扩展抽象类的新方法，子类将很容易的就能得到这些新方法。
8、如果一个类里有抽象方法，那么这个类只能是抽象类
9、抽象方法要被实现，所以不能是静态的，也不能是私有的。
10、接口可继承接口，并可多继承接口，但类只能单根继承。

6.3 了解软件设计的开闭原则ocp

开放功能扩展，关闭源码修改。等
开闭原则的英文全称是Open Close Principle，缩写是OCP，它是Java世界里最基础的设计原则，它指导我们如何建立一个稳定的、灵活的系统。
开闭原则的定义是：软件中的对象（类、模块、函数等）应该对于扩展是开放的，但是对于修改是封闭的。
开闭原则，是一种设计模式，随着面向对象程序设计的思想，应运而生。
开，指的是可以在源代码的基础上进行扩展，比如继承，接口，抽象类等。在JAVA中，之所以用继承，是在可以直接调用类库的前提下，对其功能进行扩展。不需要应用者去了解封装类的内部逻辑就可以做开发。
闭：指不允许对原有的代码进行修改。以免影响其他现有功能，造成功能瘫痪。