面向对象（二）
final关键字(掌握)
1、是最终的意思，可以修饰类，方法，变量。 2、特点： A:它修饰的类，不能被继承。 B:它修饰的方法，不能被重写。 C:它修饰的变量，是一个常量。 3、面试相关： A:局部变量 a:基本类型 值不能发生改变 b:引用类型 地址值不能发生改变，但是对象的内容是可以改变的 B:初始化时机 a:只能初始化一次。 b:常见的给值 定义的时候。(推荐) 构造方法中。 4、应用场景 ： 由于继承中方法有一个现象：方法重写。 所以，父类的功能，就会被子类给覆盖调。 有些时候，我们不想让子类去覆盖掉父类的功能，只能让他使用。 这个时候，针对这种情况，Java就提供了一个关键字：final
多态(掌握)
1、同一个对象在不同时刻体现出来的不同状态。
2、多态的前提：
A:有继承或者实现关系。
B:有方法重写。
C:有父类或者父接口引用指向子类对象。
eg:父 f = new 子();
多态的分类：
a:具体类多态
class Fu {}
class Zi extends Fu {}
Fu f = new Zi();
b:抽象类多态
abstract class Fu {}
class Zi extends Fu {}
Fu f = new Zi();
c:接口多态
interface Fu {}
class Zi implements Fu {}
Fu f = new Zi();
3、多态中的成员访问特点
A:成员变量
编译看左边，运行看左边
B:构造方法
子类的构造都会默认访问父类构造
C:成员方法
编译看左边，运行看右边
D:静态方法
编译看左边，运行看左边
为什么?
因为成员方法有重写。
4、多态的好处：
A:提高代码的维护性(继承体现)
B:提高代码的扩展性(多态体现)
5、多态的弊端：
父不能使用子的特有功能。
现象：
子可以当作父使用，父不能当作子使用。
6、多态中的转型
A:向上转型
从子到父
B:向下转型
从父到子
7、孔子装爹的案例帮助大家理解多态
抽象类(掌握)
1、把多个共性的东西提取到一个类中，这是继承的做法。 但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体不同。 也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。 所以，我们在定义这些共性的方法的时候，就不能给出具体的方法体。 而一个没有具体的方法体的方法是抽象的方法，形容抽象的不存在的事物。 在一个类中如果有抽象方法，该类必须定义为抽象类。 2、抽象类的特点 A:抽象类和抽象方法必须用关键字abstract修饰 B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类 C:抽象类不能实例化 D:抽象类的子类 a:是一个抽象类。 b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。 3、抽象类的成员特点： A:成员变量 有变量，有常量 B:构造方法 有构造方法 C:成员方法 有抽象，有非抽象 4、抽象类的几个小问题 A:抽象类有构造方法，不能实例化，那么构造方法有什么用? 用于子类访问父类数据的初始化 B:一个类如果没有抽象方法,却定义为了抽象类，有什么用? 为了不让创建对象 C:abstract不能和哪些关键字共存 a:final 冲突 b:private 冲突 c:static 无意义
接口(掌握)
1、回顾猫狗案例，它们仅仅提供一些基本功能。
比如：猫钻火圈，狗跳高等功能，不是动物本身就具备的，
是在后面的培养中训练出来的，这种额外的功能，java提供了接口表示。
2、接口的特点：
A:接口用关键字interface修饰
interface 接口名 {}
B:类实现接口用implements修饰
class 类名Impl implements 接口名 {}
C:接口不能实例化
D:接口的实现类
a:是一个抽象类。
b:是一个具体类，这个类必须重写接口中的所有抽象方法。
3、接口的成员特点：
A:成员变量
只能是常量
默认修饰符：public static final
B:构造方法
没有构造方法
C:成员方法
只能是抽象的
默认修饰符：public abstract
4、类与类,类与接口,接口与接口
A:类与类
继承关系，只能单继承，可以多层继承
B:类与接口
实现关系，可以单实现，也可以多实现。
还可以在继承一个类的同时，实现多个接口
C:接口与接口
继承关系，可以单继承，也可以多继承
5、抽象类和接口的区别
A:成员区别
抽象类：
成员变量：可以变量，也可以常量
构造方法：有
成员方法：可以抽象，也可以非抽象
接口：
成员变量：只可以常量
成员方法：只可以抽象
B:关系区别
类与类
继承，单继承
类与接口
实现，单实现，多实现
接口与接口
继承，单继承，多继承
C:设计理念不同
抽象类：is a，抽象类中定义的是共性功能。
接口：like a，接口中定义的是扩展功能。
形式参数和返回值的问题(理解)
1、形式参数： 类名：需要该类的对象 抽象类名：需要该类的子类对象 接口名：需要该接口的实现类对象 2、返回值类型： 类名：返回的是该类的对象 抽象类名：返回的是该类的子类对象 接口名：返回的是该接口的实现类的对象 3、链式编程 对象.方法1().方法2().......方法n(); 这种用法：其实在方法1()调用完毕后，应该一个对象； 方法2()调用完毕后，应该返回一个对象。 方法n()调用完毕后，可能是对象，也可以不是对象。
包(理解)
1、其实就是文件夹 2、作用： A:区分同名的类 B:对类进行分类管理 a:按照功能分 b:按照模块分 3、包的定义(掌握) package 包名; 多级包用.分开。 4、注意事项：(掌握) A:package语句必须在文件中的第一条有效语句 B:在一个java文件中，只能有一个package C:如果没有package，默认就是无包名 5、带包的编译和运行 A:手动式 B:自动式(掌握) javac -d . HelloWorld.java
导包(掌握)
1、我们多次使用一个带包的类，非常的麻烦，这个时候，Java就提供了一个关键字import。 2、格式： import 包名...类名; 另一种： import 包名...*;(不建议) 3、package,import,class的顺序 package > import > class
权限修饰符(掌握)
1、权限修饰符
本类 同一个包下 不同包下的子类 不同包下的无关类
private Y
默认 Y Y
protected Y Y Y
public Y Y Y Y
2、这四种权限修饰符在任意时刻只能出现一种。
public class Demo {}
内部类(理解)
1、把类定义在另一个类的内部，该类就被称为内部类。
举例：把类B定义在类A中，类B就被称为内部类。
2、内部类的访问规则
A:可以直接访问外部类的成员，包括私有
B:外部类要想访问内部类成员，必须创建对象
3、内部类的分类
A:成员内部类
B:局部内部类
4、成员内部类
A:private 为了数据的安全性
B:static 为了访问的方便性
成员内部类不是静态的：
外部类名.内部类名 对象名 = new 外部类名.new 内部类名();
成员内部类是静态的：
外部类名.内部类名 对象名 = new 外部类名.内部类名();
5、成员内部类的面试题(填空)
30,20,10
class Outer {
public int num = 10;
class Inner {
public int num = 20;
public viod show() {
int num = 30;
System.out.println(num);
System.out.println(this.num);
System.out.println(Outer.this.num);
}
}
}
6、局部内部类
A:局部内部类访问局部变量必须加final修饰。
B:为什么呢?
因为局部变量使用完毕就消失，而堆内存的数据并不会立即消失。
所以，堆内存还是用该变量，而改变量已经没有了。
为了让该值还存在，就加final修饰。
通过反编译工具我们看到了，加入final后，堆内存直接存储的是值，而不是变量名。
7、匿名内部类(掌握)
A:是局部内部类的简化形式
B:前提
存在一个类或者接口
C:格式:
new 类名或者接口名() {
重写方法;
}
D:本质：
其实是继承该类或者实现接口的子类匿名对象
8、匿名内部类在开发中的使用
我们在开发的时候，会看到抽象类，或者接口作为参数。
而这个时候，我们知道实际需要的是一个子类对象。
如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。
interface Person {
public abstract void study();
}
class PersonDemo {
public void method(Person p) {
p.study();
}
}
class PersonTest {
public static void main(String[] args) {
PersonDemo pd = new PersonDemo();
pd.method(new Person() {
public void study() {
System.out.println("好好学习，天天向上");
}
});
}
}
9、匿名内部类的面试题(补齐代码)
interface Inter {
void show();
}
class Outer {
//补齐代码
public static Inter method() {
return new Inter() {
public void show() {
System.out.println("HelloWorld");
}
};
}
}
class OuterDemo {
public static void main(String[] args) {
Outer.method().show(); //"HelloWorld"
}
}
