4、多态
4.1 多态的概念
多态是继封装、继承之后，面向对象的第三大特性。
多态： 是指同一行为，具有多个不同表现形式。
4.2 多态的体现
格式：
父类名称 对象名 = new 子类名称（）；
或者
接口名称 对象名 = new 实现类名称（）；
代码示例：
//定义父类 public class Fu { public void method(){ System.out.println("父类方法"); } }
//定义子类 public class Zi extends Fu{ @Override public void method() { System.out.println("子类方法"); } }
//
//定义测试类 public class Demo01Multi { public static void main(String[] args) { //使用多态写法 Fu obj = new Zi(); obj.method(); } }
5、final关键字
final关键字： 不可改变。可以用于修饰类、方法和变量。
类：被修饰的类，不能被继承。
方法：被修饰的方法，不能被重写。
变量：被修饰的变量，不能被重新赋值。
5.1使用方法
修饰类
格式：
final class 类名 {
}
注意：一个类如果是final的，纳闷这个类不能有任何子类。且其中所有的成员方法都无法进行覆盖重写。
修饰方法
格式：
修饰符 final 返回值类型 方法名(参数列表){
//方法体
}
注意：1、当final关键字修饰一个方法时，这个方法就是最终方法，也就是不能进行覆盖重写。2、对于类、方法来说，abstract关键字和final关键字不能同时使用。
修饰局部变量
注意：一旦使用final关键字来修饰局部变量，那么这个变量就不能改变
“一次赋值，终生不变”
代码示例：
/
public class FinalDemo1 { public static void main(String[] args) { // 声明变量，使用final修饰 final int a; // 第一次赋值 a = 10; // 第二次赋值 //a = 20; 报错,不可重新赋值 // 声明变量，直接赋值，使用final修饰 final int b = 10; // 第二次赋值 //b = 20; 报错,不可重新赋值 } }
成员变量
如果使用final关键字，那么这个变量也照样不可改变。
注意：
1、由于成员变量具有默认值，所以用了final之后就必须手动赋值，不会再给默认值了。
2、对于final的成员变量，那么使用直接赋值，那么通过构造方法赋值。二者选其一
3、必须保证类当中所有重载的构造方法，都会最终对final的成员变量进行赋值。
6、权限修饰符
在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，
- public：公共的。
- protected：受保护的
- default：默认的
- private：私有的
public >protected >default > private
编写代码时，如果没有特殊的考虑，建议这样使用权限：
- 成员变量使用 private ，隐藏细节。
- 构造方法使用 public ，方便创建对象。
- 成员方法使用 public ，方便调用方法。
7、内部类
将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。
7.1 成员内部类
定义在类中方法外的类。
格式：
class 外部类名称 {
class 内部类名称{
}
}
注意：
1、内部类可以直接访问外部类的成员，包括私有成员。
2、外部类要访问内部类的成员，必须要建立内部类的对象。
内部类的使用方法
1、间接方式：在外部类的方法中，使用内部类，然后main只是调用外部类的方法
2、直接方式：
类名称 对象名 = new 类名称（）；
【外部类名称. 内部类名称 对象名 = new 外部类名称 ( ) .new 内部类名称 ( ); 】
注意：内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号 。
比如，Person $ Heart.class
代码示例：
//定义类 public class Body { public class Heart{ //成员内部类 public void beat(){ System.out.println("内部类的方法"); System.out.println("我叫："+name); } } //外部类的成员变量 private String name; public void methodBody(){ System.out.println("外部类的方法"); new Heart().beat(); } public String getName() { return name; } public void setName(String name) { this.name = name; } }
//定义测试类 public class Demo01InnerClass { public static void main(String[] args) { Body body = new Body(); //通过外部类的对象，调用外部类的方法，里面间接再使用内部类Heart body.methodBody(); System.out.println("================"); Body.Heart heart = new Body().new Heart(); heart.beat(); } }
7.2 匿名内部类
是内部类的简化写法。它的本质是一个 带具体实现的 父类或者父接口的 匿名的 子类对象。开发中，最常用到的内部类就是匿名内部类了。
如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】
定义格式：
接口名称 对象名 = new 接口名称（）｛
//覆盖重写所有抽象方法
｝；
注意：
1、匿名内部类，在创建对象的时候，只能使用唯一一次。
如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了
2、匿名对象，在【调用方法】的时候，只能调用唯一一次。
如果希望同一个对象，调用多次方法，那么必须给对象起名字。
3、匿名内部类是省略了【实现类/子类名称】，但是匿名对象省略了【对象名称】
强调：匿名内部类和匿名对象不是一回事！！！
代码示例：
//定义接口 public interface MyInterface { void method();//抽象方法 }
//定义实现类 public class Demomain { public static void main(String[] args) { //使用匿名内部类 MyInterface obj = new MyInterface() { @Override public void method() { System.out.println("匿名内部类实现了方法"); } }; obj.method(); } }
