知识回顾

面向对象

用代码去高度模拟现实世界，以便为人类的业务服务。
Java是一种面向对象的高级编程语言。
高级编程语言：代码风格很像人类的自然语言。
zhubajie.eat(“西瓜”);

面向对象最重要的两个概念：类和对象。

类

是描述相同事物的共同特征的抽象。人类。

对象

是具体存在的实例，是真实的。实例==对象

在代码层面：必须先有类，才能创建出对象。

定义类的格式

修饰符 class 类名{
// 1.成员变量（Field：描述类和对象的属性信息的）.
// 2.成员方法（Method:描述类或者对象的行为信息的）
// 3.构造器（Constructor:初始化一个类的对象并返回引用）
// 4.代码块
// 5.内部类
}

注意

– 类名的首字母应该大写，满足“驼峰写法”。
– 一个Java代码文件中可以定义多个类。但是只能有一个类
是用public修饰的，而且public修饰的类名必须成为代码的文件名称。

类中的成分研究

类中有且仅有五大成分

1.成员变量（Field：描述类和对象的属性信息的）.
2.成员方法（Method:描述类或者对象的行为信息的）
3.构造器（Constructor:初始化一个类的对象并返回引用）
4.代码块
5.内部类

注意：只要不是这5大成分放在类下就会报错

构造器的复习

作用

初始化一个类的对象并返回引用。

格式

修饰符类名(形参){

}

构造器初始化对象的格式

类名对象名称 = new 构造器;

注意：一个类默认会自带一个无参数构造器，即使不写它也存在，但是如果一个类它写了一个构造器，那么默认的无参数构造器就被覆盖了!!

this关键字的作用

this代表了当前对象的引用
this关键字可以用在实例方法和构造器中
this用在方法中，谁调用这个方法，this就代表谁
this用在构造器，代表了构造器正在初始化的那个对象的引用

static关键字

引入

我们之前定义了很多成员变量（name , age , sex）
其实我们只写了一份，但是发现每个对象都可以用，就说明
Java中这些成员变量或者方法是存在所属性的。
有些是属于对象的，有些是属于类本身的。

Java是通过成员变量是否有static修饰来区分是类的还是属于对象的。

static == 静态 == 修饰的成员（方法和成员变量）属于类本身的。

分类

按照有无static修饰，成员变量和方法可以分为：

成员变量：
（1）静态成员变量（类变量）：
有static修饰的成员变量称为静态成员变量也叫类变量，属于类本身的，

直接用类名访问即可。

2）实例成员变量
无static修饰的成员变量称为实例成员变量，属于类的每个对象的

必须用类的对象来访问。

成员方法：
（1）静态方法
有static修饰的成员方法称为静态方法也叫类方法，属于类本身的

直接用类名访问即可

2）实例方法
无static修饰的成员方法称为实例方法，
属于类的每个对象的，必须用类的对象来访问

小结

成员变量有2种
– 有static修饰的属于类叫静态成员变量，与类一起加载一次，直接用类名调用即可。
– 无static修饰的属于类的每个对象的叫实例成员变量，
与类的对象一起加载，对象有多少个，实例成员变量就加载多少份。必须用类的对象调用。

成员方法有2种：

– 有static修饰的属于类叫静态方法，直接用类名调用即可。
– 无static修饰的属于类的每个对象的叫实例方法，必须用类的对象调用

this和super关键字使用总结

this代表了当前对象的引用（继承中指代子类对象）：
this.子类成员变量。
this.子类成员方法。
this(…):可以根据参数匹配访问本类其他构造器。（还没有学习）
super代表了父类对象的引用（继承中指代了父类对象空间）
super.父类成员变量。
super.父类的成员方法。
super(…):可以根据参数匹配访问父类的构造器。
拓展：this(…)根据参数匹配访问本类其他构造器。
注意：
this(…)借用本类其他构造器。
super(…)调用父类的构造器。
this(…)和super(…)必须放在构造器的第一行，否则报错!
所以this(…)和super(…)不能同时出现在构造器中!!!

final关键字

final是最终的含义。
final用于修饰：类，方法，变量
1.final修饰类，类不能被继承了。
2.final可以修饰方法，方法就不能被重写了。
3.final修饰变量总规则：变量有且仅能被赋值一次。

拓展：final和abstract的关系?

互斥关系,不能同时修饰类或者同时修饰方法！！

修饰变量

final修饰变量的总规则：有且仅能被赋值一次。

变量有几种？
成员变量
– 静态成员变量：有static修饰，属于类，只加载一份。
– 实例成员变量：无static修饰，属于每个对象,与对象一起加载。
局部变量
– 只能方法中，构造器中，代码块中，for循环中，用完作用范围就消失了。
### 修饰局部变量：
– 让值被固定或者说保护起来，执行的过程中防止被修改。

修饰静态成员变量

final修饰变量的总规则：有且仅能被赋值一次。
final修饰静态成员变量，变量变成了常量。
常量：有public static final修饰，名称字母全部大写，多个单词用下划线连接。

修饰实例成员变量

inal修饰变量的总规则：有且仅能被赋值一次。
拓展：
final修饰实例成员变量可以在哪些地方赋值1次：
1.定义的时候赋值一次。
2.可以在实例代码块中赋值一次。
3.可以在每个构造器中赋值一次。

成员变量的分类和访问

按照有无static修饰成员变量分为：

（1）静态成员变量：

有static修饰，属于类本身与类一起加载一次，直接用类名访问即可。

（2）实例成员变量：无static修饰，属于类的每个对象的，必须先创建对象，再用对象来访问。

成员变量的访问语法：
静态成员变量访问：
类名.静态成员变量。
对象.静态成员变量。（不推荐）
实例成员变量的访问：
对象.实例成员变量。

成员方法的分类和访问

成员方法按照有无static修饰可以分为：

（1）静态方法：

有static修饰，属于类，直接用类名访问即可

（2）实例方法：

无static修饰，属于对象的，必须用对象来访问。

成员方法的访问语法：
静态方法的访问格式：
类名.静态方法
对象.静态方法（不推荐）
实例方法的访问格式：
对象.实例方法

小结：

静态方法属于类，有static修饰，直接用类名访问即可。

实例方法属于对象，无static修饰，必须先创建对象，然后用对象来访问。

静态方法也可以被对象共享访问，但是不推荐，因为静态方法直接用类名访问即可。

成员变量和成员方法访问的拓展

面试常考

方法：实例方法，静态方法。
成员变量：实例成员变量，静态成员变量。
8种访问形式的问答：
a.实例方法是否可以直接访问实例成员变量？可以的，因为它们都属于对象。
b.实例方法是否可以直接访问静态成员变量？可以的，静态成员变量可以被共享访问。
c.实例方法是否可以直接访问实例方法? 可以的，实例方法和实例方法都属于对象。 d.实例方法是否可以直接访问静态方法？可以的，静态方法可以被共享访问！

a.静态方法是否可以直接访问实例变量？不可以的，实例变量必须用对象访问！！
b.静态方法是否可以直接访问静态变量？可以的，静态成员变量可以被共享访问。
c.静态方法是否可以直接访问实例方法? 不可以的，实例方法必须用对象访问！！
d.静态方法是否可以直接访问静态方法？可以的，静态方法可以被共享访问！！

抽象类

抽象类的概述

什么是抽象类

父类知道子类一定要完成某个功能，但是每个子类实现的情况都不一样.
子类都会用自己重写的功能了，父类的该功能就可以定义成抽象的方法。

什么是抽象方法

没有方法体，只有方法签名，必须用abstract修饰的方法就是抽象方法。
拥有抽象方法的类必须定义成抽象类

抽象类：必须用abstract关键字修饰

抽象类的使用

抽象类的作用：为了被子类继承。

抽象类是为了被子类继承,约束子类要重写抽象方法！

注意：一个类继承了抽象类，必须重写完抽象类的全部抽象方法，否则这个类必须定义成抽象类。

抽象类的特征研究和深入

抽象类的特征：有得有失。
有得：抽象类拥有了得到抽象方法的能力。
失去：抽象类失去了创建对象的能力

面试题：抽象类是否有构造器，是否可以创建对象，为什么?
答：抽象类作为类一定有构造器，而且必须有构造器。
提供给子类继承后调用父类构造器使用的。抽象类虽然有构造器，但是抽象类绝对不能创建对象。抽象类中可能存在抽象方法，抽象方法不能执行。抽象在学术上本身意味着不能实例化。

抽象类除了有得有失之外，类的其他成分人家都具备！！抽象类中也可以没有抽象方法！！

抽象类的意义

抽象类存在的意义有两点：
（1）被继承，抽象类就是为了被子类继承，(为了派生子类)否则抽象类将毫无意义。(核心意义)
（2）抽象类体现的是”模板思想”：部分实现，部分抽象。（拓展）
– 可以使用抽象类设计一个模板模式。

抽象类的注意事项和总结

抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
抽象类一定有而且是必须有构造器，是供子类创建对象时，初始化父类成员使用的。
理解：子类的构造器中，有默认的super()，需要访问父类构造器。
抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
抽象类的子类，必须重写抽象父类中所有的抽象方法，否则子类也必须定义成抽象类。
抽象类存在的意义是为了被子类继承，抽象类体现的是模板思想。
理解：抽象类中已经实现的是模板中确定的成员，
抽象类不确定如何实现的定义成抽象方法，交给具体的子类去实现。

代码块

代码块是类的成分之一：
成员变量，成员方法，构造器，代码块，内部类。

代码块按照有无static修饰分为：
1.静态代码块。
2.实例代码块

静态代码块的格式：
static {

}

静态代码块

静态代码块特点：
– 必须有static修饰。
– 会与类一起优先加载，且自动触发执行一次。
静态代码块作用：
– 可以在执行类的方法等操作之前先在静态代码块中进行静态资源的初始化操作。(拓展)

实例代码块

实例代码块的格式：

{

}

实例代码块的特点：
– 无static修饰。
– 会与类的对象一起加载，每次创建类的对象的时候，
实例代码块都会被加载且自动触发执行一次。
– 实例代码块的代码在底层实际上是提取到每个构造器中去执行的！

实例代码块的作用：

– 实例代码块可以在创建对象之前进行实例资源的初始化操作。

枚举

枚举的概述和作用

枚举是Java中的一种特殊类型。
枚举的作用：是为了做信息的标志和信息的分类

定义枚举的格式：

修饰符 enum 枚举名称{
第一行都是罗列枚举实例的名称。
}

枚举类的编译以后源代码

public final class Season extends java.lang.Enum<Season> {
            public static final Season SPRING = new Season();
            public static final Season SUMMER = new Season();
            public static final Season AUTUMN = new Season();
            public static final Season WINTER = new Season();

            public static Season[] values();
            public static Season valueOf(java.lang.String);
        }

枚举的特点：
1.枚举类是用final修饰的，枚举类不能被继承！
2.枚举类默认继承了java.lang.Enum枚举类。
3.枚举类的第一行都是常量,存储都是枚举类的对象。
4.枚举类的第一行必须是罗列枚举类的实例名称。
所以：枚举类相当于是多例设计模式。

常量做信息分类和信息标志：
虽然可以实现可读性，但是入参不受限制！！！

Java建议做信息标志和信息分类应该使用枚举实现：最优雅的方式。
可以实现可读性，而且入参受限制，不能乱输入！！！

内部类

什么是内部类

定义在一个类里面的类就是内部类

内部类有什么用

可以提供更好的封装性, 内部类有更多权限修饰符 , 封装性有更多的控制。
可以体现出组件的思想

内部类的分类

1）静态内部类。
（2）实例内部类。（成员内部类）
（3）局部内部类。
（4）匿名内部类。（重点）

静态内部类

什么是静态内部类？
有static修饰，属于外部类本身，会加载一次。
静态内部类中的成分研究：
类有的成分它都有，静态内部类属于外部类本身，只会加载一次
所以它的特点与外部类是完全一样的，只是位置在别人里面而已。

静态内部类中的成分研究：
类有的成分它都有，静态内部类属于外部类本身，只会加载一次
所以它的特点与外部类是完全一样的，只是位置在别人里面而已。

外部类=宿主
内部类=寄生

静态内部类的访问格式：
外部类名称.内部类名称

静态内部类创建对象的格式：
外部类名称.内部类名称对象名称 = new 外部类名称.内部类构造器;

静态内部类的访问拓展：
静态内部类中是否可以直接访问外部类的静态成员?可以的，外部类的静态成员只有一份，可以被共享！
静态内部类中是否可以直接访问外部类的实例成员?不可以的,外部类的是成员必须用外部类对象访问！！

小结：
静态内部类属于外部类本身，只会加载一次
所以它的特点与外部类是完全一样的，只是位置在别人里面而已。

实例内部类

什么是实例内部类：
无static修饰的内部类，属于外部类的每个对象的，跟着对象一起加载的。
实例内部类的成分特点：
实例内部类中不能定义静态成员，其他都可以定义。
可以定义常量。
实例内部类的访问格式：
外部类名称.内部类名称。
创建对象的格式：
外部类名称.内部类名称对象名称 = new 外部类构造器.new 内部构造器;
拓展：

实例内部类中是否可以直接访问外部类的静态成员？可以的，外部类的静态成员可以被共享访问！

实例内部类中是否可以访问外部类的实例成员？可以的，实例内部类属于外部类对象，可以直接访问当前外部类对象的实例成员！
小结：
实例内部类属于外部类对象，需要用外部类对象一起加载，
实例内部类可以访问外部类的全部成员！

局部内部类（几乎不用）

定义在方法中，在构造器中，代码块中，for循环中定义的内部类
就是局部内部类。
局部内部类中的成分特点：只能定义实例成员，不能定义静态成员
可以定义常量的。
小结：
局部内部类没啥用。

匿名内部类(重点)

什么是匿名内部类？
就是一个没有名字的局部内部类。
匿名内部类目的是为了：简化代码，也是开发中常用的形式。
匿名内部类的格式：
new 类名|抽象类|接口(形参){
方法重写。
}
匿名内部类的特点：
1.匿名内部类是一个没有名字的内部类。
2.匿名内部类一旦写出来，就会立即创建一个匿名内部类的对象返回。
3.匿名内部类的对象的类型相当于是当前new的那个的类型的子类类型。

包和权限修饰符

包

分门别类的管理各种不同的技术。企业的代码必须用包区分。便于管理技术，扩展技术，阅读技术。
定义包的格式：package 包名; 必须放在类名的最上面。
一般工具已经帮我们做好了。
包名的命名规范：
一般是公司域名的倒写+技术名称：
http://www.itheima.com => com.itheima.技术名称

包名建议全部用英文，多个单词用”.“连接，必须是合法标识符，不能用关键字
## 注意：
相同包下的类可以直接访问。
不同包下的类必须导包,才可以使用！
导包格式：import 包名.类名;

权限修饰符

权限修饰符：有四种（private -> 缺省 -> protected - > public ）可以修饰成员变量，修饰方法，修饰构造器，内部类，不同修饰符修饰的成员能够被访问的权限将受到限制!
四种修饰符的访问权限范围：

	private	缺省	protected	public
本类中	√	√	√	√
本包下其他类中	X	√	√	√
其他包下的类中	X	X	X	√
其他包下的子类中	X	X	√	√