今日内容
-
多态
-
final
-
权限修饰符
-
内部类
多态
##### 概述
多态是继封装性，继承性之后，面向对象的第三大特性。
定义
多态：是指同一行为，具有多个不同的表现形式。
生活中，比如跑的动作，猫，狗，大象跑起来的动作都是不一样的，再比如飞的动作，昆虫、鸟类、人造飞机，飞起来的动作内容都是不一样的。可见，同一行为，通过不同的事物，可以表现出不同的形态。多态，描述的就是这样的一种状态。
#### 前提
-
继承或者实现【二选其一】
-
父类的引用指向子类的对象 【格式体现】
-
方法的重写 【意义：不重写，是无意义的】
多态的表现
多态表现的格式：
父类类型 变量名 = new 子类对象; 变量名.方法名();备注：父类类型指的是子类对象继承的父类类型，或者实现的父接口类型
public class Fu { public void method() { System.out.println("这是父类的method方法"); } } // 1. 继承关系 public class Zi extends Fu { // 2. 方法的重写 @Override public void method(){ System.out.println("这是子类的method方法被执行。。。"); } } // polymorphism 多态 public class TestPolyDemo01 { public static void main(String[] args) { // 多态的格式 /* 父类类型 变量名 = new 子类对象; 变量名.方法名(); */ // 3.父类的引用指向了子类的对象 Fu fu = new Zi(); fu.method();// 本质调用的是子类当中重写之后的method方法 } }如果在使用多态方式调用方法时，首先检查父类当中是否有该方法，如果没有，则编译报错，如果有，执行的是子类重写后的方法。
多态的好处
在实际开发中，父类类型作为方法的形式参数（不同于实际参数），传递子类对象(实参)给方法，进行方法的调用，更能体现出多态的扩展性和便利性。代码如下：
// 定义抽象的父类 public abstract class Animal{ // 定义一个抽象的方法 public abstract void eat(); public void run(){ System.out.println("用脚跑。。。"); } } // 定义子类 public class Cat extends Animal { @Override public void eat() { System.out.println("猫吃鱼"); } } public class Dog extends Animal { @Override public void eat() { System.out.println("狗啃骨头"); } } public class Bird extends Animal { @Override public void eat(){ System.out.println("鸟吃虫"); } } // 定义测试类 public class TestDemo03 { public static void main(String[] args) { // 根据不同的对象，来表现不同的吃的内容 Cat c = new Cat(); showCatEat(c);// 猫吃鱼 Dog dog = new Dog(); showDogEat(dog);// 狗啃骨头 Bird bird = new Bird(); bird.eat();// 鸟吃虫子。。 Cat c2 = new Cat(); showAnimalEat(c2); // Dog dog2 = new Dog(); showAnimalEat(dog2); } /* public static void showCatEat(Cat cat) { cat.eat();// 猫吃鱼 } public static void showDogEat(Dog dog) { dog.eat(); } public static void showBirdEat(Bird bird) { bird.eat(); }*/ /* 以上三个方法可以用来多态进行优化,可以被showAnimalEat方法所替代 */ public static void showAnimalEat(Animal animal) { animal.eat(); animal.run(); } }说明：用于多态特性的支持，showAnimalEat方法当中的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当然可以把cat对象和dog对象传递给方法。
当程序执行过程中。执行eat方法实际执行的是各自子类对象重写之后的eat方法
不仅仅可以做到替代，在扩展性方面，无论之后出现多个子类，都不需要编写showXxxEat方法了，直接使用showAnimalEat()方法了。
所以，多态的好处，体现在可以使程序编写更简单，并且具有良好的扩展性。
访问类中成员变量有两种方式：
1. 直接通过对象名访问成员变量：看等号左边是谁，优先用谁，没有继续往上找
2. 间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则继续往上找。
// 定义一个父类
public class Fu {
int num = 10;
// 定义成员方法
public void showNum() {
System.out.println(num);
}
}
// 定义子类
public class Zi extends Fu {
int num = 20;
@Override
public void showNum(){
System.out.println(super.num);
}
}
// 定义测试类
public class TestPolyFieldDemo01 {
public static void main(String[] args) {
// 多态的表示形式
// 父类类型 变量名 = new 子类对象;
// 变量名.成员变量名
Fu fu = new Zi();
System.out.println(fu.num);// 10
fu.showNum();// 20
Zi zi = new Zi();
}
}
引用数据类型的转型
多态的转型分为向上转型和向下转型两种：
###### 向上转型
向上转型：多态本身就是子类类型向父类类型向上转型的过程，这个过程师默认的。
当一个父类引用指向了一个子类对象时，便是向上转型。
使用格式：
父类类型 变量名 = new 子类类型();
比如： Animal animal = new Cat();
向下转型
向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。
一个已经向上转型的子类对象，将父类的引用转为子类应用，可以使用强制类型转换的格式，便是向下转型。
使用格式：
子类类型 变量名 = (子类类型) 父类变量名;
比如： Cat cat = (Cat) animal;
转型的异常
在进行向下转换的过程中，一不小心就出现java.lang.ClassCastException类型转换异常。
为了避免这种类型转换异常的发生，Java提供了instanceof关键字，给引用变量做类型的校验。
格式如下：
变量名 instanceof 数据类型
如果变量属于该数据类型，则返回true
如果变量不属于该数据类型，则返回false
所以，我们在转换前，我们最好先进行引用变量的类型判断，代码如下：
public class Test {
public static void main(String[] args) {
// 向上转型
Animal animal = new Cat();
// 向下转型
if (animal instanceof Cat) {
// 表明你就是一只猫
Cat cat = (Cat) animal;
cat.eat();// 吃鱼
cat.catchMouse();// 逮老鼠
} else if (animal instanceof Dog) {
// 表明你就是一只狗
Dog dog = (Dog) animal;
dog.lookDoor();
}
}
}
学习目标：
-
final
-
权限修饰符
-
内部类
-
引用类型
具体内容：
- 描述final修饰的类的特点
- 描述final修饰的方法的特点
- 能够说出权限修饰符作用范围
- 说出内部类的概念
- 能够理解引用类型作为成员变量
- 能够理解引用类型作为方法参数
- 能够理解引用类型作为方法返回值类型
final
###### 概述
由于Java当中提供了继承特性，子类可以在父类的基础上改写父类的内容，比如：方法的重写，那么能不能随意的继承API当中提供的类呢，改写其内容呢？显然是不行的，为了避免这种随意更改的情况，java提供了final关键字，用于修饰不可改变的内容。
-
final：不可变。用于修饰类、方法和变量
-
类：被修饰的类，不能被继承
-
方法：被修饰的方法，不能被重写
-
变量：被修饰的变量，不能被【重新赋值】
-
使用方式
修饰类
格式如下：
public final class 类名 {
// 类信息
}
通过查询API发现，JDK官方提供了很多的被final修饰的类如：String、Math、Scanner、Character等，这些类都是被final修饰的，目的是让我们仅使用，而不让我们更改其内容。
修饰方法
格式如下：
修饰符 final 返回值类型 方法名（参数列表） {
// 方法体内容。。。。。
}
重写final修饰的方法，编译无法通过。
修饰变量
-
修饰局部变量------基本类型
基本类型的局部变量，被final修饰后，只能赋值一次，不能被更改。代码如下：
public class Demo { public static void main(String[] args) { // 声明局部变量 final int num; // 第一次赋值 num = 10; // 第二次赋值 num = 20;// 编译报错 } }思考：
如下两种写法，哪种可以通过编译？
// 第一种写法 final int num = 0; for (int i = 0; i < 10; i++) { num = i; System.out.println(num); } // 第二种写法 for (int i = 0; i <10; i++){ final int num = i; System.out.println(num); }-
局部变量---------引用类型
引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能发生改变，但是不影响对象内部的成员变量的修改。代码如下：
public class FinalDemo2 { public static void main(String[] args) { // 构建一个对象 final People p1 = new People(); p1 = new People();// 报错，编译无法通过 // 调用setName()方法 p1.setName("小王");// 可以修改 } }-
成员变量
成员变量涉及到【初始化】的问题，初始化方式有两种，二选其一：
-
显示初始化；
public class People { final String NAME = "小王"; private int age; }-
构造方法初始化。
public class People { final String NAME; private int age; public People(String name) { this.name = name; } }
-
-
-
-
备注：被final修饰的常量名称，一般都有书写规范，所有字母均为【大写】。