目录
6、IDEA查看构造器和方法形参列表快捷键：Ctrl + P
6.3 多态（Polymorphism）
多态是继封装、继承之后，面向对象的第三大特性。它表示一个对象具有多重特征，可以在特定的情况下表现出不同的状态。
6.3.1 多态解决什么样的问题
有的时候，我们在设计一个数组、或一个成员变量、或一个方法的形参、返回值类型时，无法确定它具体的类型，只能确定它是某个系列的类型。
案例：
（1）声明一个Dog类，包含public void eat()方法，输出“狗狗啃骨头”
（2）声明一个Cat类，包含public void eat()方法，输出“猫咪吃鱼仔”
（3）声明一个Person类，
-
包含宠物属性
-
包含领养宠物方法 public void adopt(宠物类型 pet)
-
包含喂宠物吃东西的方法 public void feed()，实现为调用宠物对象.eat()方法
问题： 1、从养狗切换到养猫怎么办？ 修改代码把Dog修改为养猫？ 2、或者有的人养狗，有的人养猫怎么办？ 3、要是同时养多个狗，或猫怎么办？ 4、要是还有更多其他宠物类型怎么办？
public class Dog {
public void eat(){
System.out.println("狗狗啃骨头");
}
}
public class Cat {
public void eat(){
System.out.println("猫咪吃鱼仔");
}
}
public class Person {
private Dog dog;
//adopt：领养
public void adopt(Dog dog){
this.dog = dog;
}
//feed：喂食
public void feed(){
if(dog != null){
dog.eat();
}
}
/*
问题：
1、从养狗切换到养猫怎么办？
修改代码把Dog修改为养猫？
2、或者有的人养狗，有的人养猫怎么办？
3、要是同时养多个狗，或猫怎么办？
4、要是还有更多其他宠物类型怎么办？
如果Java不支持多态，那么上面的问题将会非常麻烦，代码维护起来很难，扩展性很差。
*/
}6.3.2 多态的形式和体现
1、多态引用
Java规定父类类型的变量可以接收子类类型的对象，这一点从逻辑上也是说得通的。
父类类型：指子类继承的父类类型。
所以说继承是多态的前提
2、多态引用的表现
表现：编译时类型与运行时类型不一致，编译时看“父类”，运行时看“子类”。
3、多态引用的好处和弊端
弊端：编译时，只能调用父类声明的方法，不能调用子类扩展的方法；
好处：运行时，看“子类”，如果子类重写了方法，一定是执行子类重写的方法体；变量引用的子类对象不同，执行的方法就不同，实现动态绑定。代码编写更灵活、功能更强大，可维护性和扩展性更好了。
4、多态演示
让Dog和Cat都继承Pet宠物类。
public class Pet {
private String nickname;
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
public void eat(){
System.out.println(nickname + "吃东西");
}
}
public class Cat extends Pet {
//子类重写父类的方法
@Override
public void eat() {
System.out.println("猫咪" + getNickname() + "吃鱼仔");
}
//子类扩展的方法
public void catchMouse() {
System.out.println("抓老鼠");
}
}
public class Dog extends Pet {
//子类重写父类的方法
@Override
public void eat() {
System.out.println("狗狗" + getNickname() + "啃骨头");
}
//子类扩展的方法
public void watchHouse() {
System.out.println("看家");
}
}
public class TestPet {
public static void main(String[] args) {
//多态引用
Pet pet = new Dog();
pet.setNickname("小白");
//多态的表现形式
/*
编译时看父类：只能调用父类声明的方法，不能调用子类扩展的方法；
运行时，看“子类”，如果子类重写了方法，一定是执行子类重写的方法体；
*/
pet.eat();//运行时执行子类Dog重写的方法
// pet.watchHouse();//不能调用Dog子类扩展的方法
pet = new Cat();
pet.setNickname("雪球");
pet.eat();//运行时执行子类Cat重写的方法
}
}6.3.3 应用多态解决问题
1、声明变量是父类类型，变量赋值子类对象
-
方法的形参是父类类型，调用方法的实参是子类对象
-
实例变量声明父类类型，实际存储的是子类对象
public class OnePersonOnePet {
private Pet pet;
public void adopt(Pet pet) {//形参是父类类型，实参是子类对象
this.pet = pet;
}
public void feed(){
pet.eat();//pet实际引用的对象类型不同，执行的eat方法也不同
}
}
public class TestOnePersonOnePet {
public static void main(String[] args) {
OnePersonOnePet person = new OnePersonOnePet();
Dog dog = new Dog();
dog.setNickname("小白");
person.adopt(dog);//实参是dog子类对象，形参是父类Pet类型
person.feed();
Cat cat = new Cat();
cat.setNickname("雪球");
person.adopt(cat);//实参是cat子类对象，形参是父类Pet类型
person.feed();
}
}2、数组元素是父类类型，元素对象是子类对象
public class OnePersonManyPets {
private Pet[] pets;//数组元素类型是父类类型，元素存储的是子类对象
public void adopt(Pet[] pets) {
this.pets = pets;
}
public void feed() {
for (int i = 0; i < pets.length; i++) {
pets[i].eat();//pets[i]实际引用的对象类型不同，执行的eat方法也不同
}
}
}
public class TestPets {
public static void main(String[] args) {
Pet[] pets = new Pet[2];
pets[0] = new Dog();//多态引用
pets[0].setNickname("小白");
pets[1] = new Cat();//多态引用
pets[1].setNickname("雪球");
OnePersonManyPets person = new OnePersonManyPets();
person.adopt(pets);
person.feed();
}
}3、方法返回值类型声明为父类类型，实际返回的是子类对象
public class PetShop {
//返回值类型是父类类型，实际返回的是子类对象
public Pet sale(String type){
switch (type){
case "Dog":
return new Dog();
case "Cat":
return new Cat();
}
return null;
}
}
public class TestPetShop {
public static void main(String[] args) {
PetShop shop = new PetShop();
Pet dog = shop.sale("Dog");
dog.setNickname("小白");
dog.eat();
Pet cat = shop.sale("Cat");
cat.setNickname("雪球");
cat.eat();
}
}6.3.4 向上转型与向下转型
首先，一个对象在new的时候创建是哪个类型的对象，它从头至尾都不会变。即这个对象的运行时类型，本质的类型用于不会变。但是，把这个对象赋值给不同类型的变量时，这些变量的编译时类型却不同。
这个和基本数据类型的转换是不同的。基本数据类型是把数据值copy了一份，相当于有两种数据类型的值。而对象的赋值不会产生两个对象。
1、为什么要类型转换呢？
因为多态，就一定会有把子类对象赋值给父类变量的时候，这个时候，在编译期间，就会出现类型转换的现象。
但是，使用父类变量接收了子类对象之后，我们就不能调用子类拥有，而父类没有的方法了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做类型转换，使得编译通过。
-
向上转型：当左边的变量的类型（父类） > 右边对象/变量的类型（子类），我们就称为向上转型
-
此时，编译时按照左边变量的类型处理，就只能调用父类中有的变量和方法，不能调用子类特有的变量和方法了
-
但是，运行时，仍然是对象本身的类型，所以执行的方法是子类重写的方法体。
-
此时，一定是安全的，而且也是自动完成的
-
-
向下转型：当左边的变量的类型（子类）<右边对象/变量的编译时类型（父类），我们就称为向下转型
-
此时，编译时按照左边变量的类型处理，就可以调用子类特有的变量和方法了
-
但是，运行时，仍然是对象本身的类型
-
不是所有通过编译的向下转型都是正确的，可能会发生ClassCastException，为了安全，可以通过isInstanceof关键字进行判断
-
2、如何向上转型与向下转型
向上转型：自动完成
向下转型：（子类类型）父类变量
public class ClassCastTest {
public static void main(String[] args) {
//没有类型转换
Dog dog = new Dog();//dog的编译时类型和运行时类型都是Dog
//向上转型
Pet pet = new Dog();//pet的编译时类型是Pet，运行时类型是Dog
pet.setNickname("小白");
pet.eat();//可以调用父类Pet有声明的方法eat，但执行的是子类重写的eat方法体
// pet.watchHouse();//不能调用父类没有的方法watchHouse
Dog d = (Dog) pet;
System.out.println("d.nickname = " + d.getNickname());
d.eat();//可以调用eat方法
d.watchHouse();//可以调用子类扩展的方法watchHouse
Cat c = (Cat) pet;//编译通过，因为从语法检查来说，pet的编译时类型是Pet，Cat是Pet的子类，所以向下转型语法正确
//这句代码运行报错ClassCastException，因为pet变量的运行时类型是Dog，Dog和Cat之间是没有继承关系的
}
}3、instanceof关键字
为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，只要用instanceof判断返回true的，那么强转为该类型就一定是安全的，不会报ClassCastException异常。
变量/匿名对象 instanceof 数据类型
那么，哪些instanceof判断会返回true呢？
-
变量/匿名对象的编译时类型 与 instanceof后面数据类型是直系亲属关系才可以比较
-
变量/匿名对象的运行时类型<= instanceof后面数据类型，才为true
6.3.5 虚方法
在Java中虚方法是指在编译阶段和类加载阶段都不能确定方法的调用入口地址，在运行阶段才能确定的方法，即可能被重写的方法。
当我们通过“对象xx.方法”的形式调用一个虚方法时，要如何确定它具体执行哪个方法呢？
（1）静态分派：先看这个对象xx的编译时类型，在这个对象的编译时类型中找到能匹配的方法
（2）动态绑定：再看这个对象xx的运行时类型，如果这个对象xx的运行时类重写了刚刚找到的那个匹配的方法，那么执行重写的，否则仍然执行刚才编译时类型中的那个匹配的方法
6.3.6 成员变量没有多态一说
public class TestVariable {
public static void main(String[] args) {
Base b = new Sub();
System.out.println(b.a);
System.out.println(((Sub)b).a);
Sub s = new Sub();
System.out.println(s.a);
System.out.println(((Base)s).a);
}
}
class Base{
int a = 1;
}
class Sub extends Base{
int a = 2;
}6.4 实例初始化
6.4.1 构造器
我们发现我们new完对象时，所有成员变量都是默认值，如果我们需要赋别的值，需要挨个为它们再赋值，太麻烦了。我们能不能在new对象时，直接为当前对象的某个或所有成员变量直接赋值呢。
可以，Java给我们提供了构造器（Constructor)。
1、构造器的作用
new对象，并在new对象的时候为实例变量赋值。
2、构造器的语法格式
构造器又称为构造方法，那是因为它长的很像方法。但是和方法还是有所区别的。
代码如下：
public class Student {
private String name;
private int age;
// 无参构造
public Student() {}
// 有参构造
public Student(String name,int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getInfo(){
return "姓名：" + name +"，年龄：" + age;
}
}注意事项：
-
构造器名必须与它所在的类名必须相同。
-
它没有返回值，所以不需要返回值类型，甚至不需要void
-
如果你不提供构造器，系统会给出无参数构造器，并且该构造器的修饰符默认与类的修饰符相同
-
如果你提供了构造器，系统将不再提供无参数构造器，除非你自己定义。
-
构造器是可以重载的，既可以定义参数，也可以不定义参数。
-
构造器的修饰符只能是权限修饰符，不能被其他任何修饰
3、同一个类中的构造器互相调用
-
this()：调用本类的无参构造
-
this(实参列表)：调用本类的有参构造
-
this()和this(实参列表)只能出现在构造器首行
-
不能出现递归调用
4、继承时构造器如何处理
-
子类继承父类时，不会继承父类的构造器。只能通过super()或super(实参列表)的方式调用父类的构造器。
-
super();：子类构造器中一定会调用父类的构造器，默认调用父类的无参构造，super();可以省略。
-
super(实参列表);：如果父类没有无参构造或者有无参构造但是子类就是想要调用父类的有参构造，则必须使用super(实参列表);的语句。
-
super()和super(实参列表)都只能出现在子类构造器的首行
5、IDEA生成构造器：Alt + Insert
6、IDEA查看构造器和方法形参列表快捷键：Ctrl + P
6.4.2 非静态代码块（了解）
-
静态代码块是在类被加载到JVM时执行的。它只执行一次，无论创建多少个类的实例。静态代码块通常用于初始化静态变量或执行只需要执行一次的类级别的初始化任务。
-
非静态代码块是在创建类的实例时执行的。每次创建新的对象时，都会执行非静态代码块。
1、非静态代码块的作用
和构造器一样，也是用于实例变量的初始化等操作。
2、非静态代码块的意义
如果多个重载的构造器有公共代码，并且这些代码都是先于构造器其他代码执行的，那么可以将这部分代码抽取到非静态代码块中，减少冗余代码。
3、非静态代码块的执行特点
所有非静态代码块中代码都是在new对象时自动执行，并且一定是先于构造器的代码执行。
4、非静态代码块的语法格式
【修饰符】 class 类{
{
非静态代码块
}
【修饰符】 构造器名(){
// 实例初始化代码
}
【修饰符】 构造器名(参数列表){
// 实例初始化代码
}
}5、非静态代码块的应用
案例：
（1）声明User类，
-
包含属性：username（String类型），password（String类型），registrationTime（long类型），私有化
-
包含get/set方法，其中registrationTime没有set方法
-
包含无参构造，
-
输出“新用户注册”，
-
registrationTime赋值为当前系统时间，
-
username就默认为当前系统时间值，
-
password默认为“123456”
-
-
包含有参构造(String username, String password)，
-
输出“新用户注册”，
-
registrationTime赋值为当前系统时间，
-
username和password由参数赋值
-
-
包含public String getInfo()方法，返回：“用户名：xx，密码：xx，注册时间：xx”
（2）编写测试类，测试类main方法的代码如下：
public static void main(String[] args) {
User u1 = new User();
System.out.println(u1.getInfo());
User u2 = new User("lee","8888");
System.out.println(u2.getInfo());
}如果不用非静态代码块，User类是这样的：
public class User {
private String username;
private String password;
private long registrationTime;
public User() {
System.out.println("新用户注册");
registrationTime = System.currentTimeMillis();
username = registrationTime+"";
password = "123456";
}
public User(String username,String password) {
System.out.println("新用户注册");
registrationTime = System.currentTimeMillis();
this.username = username;
this.password = password;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public long getRegistrationTime() {
return registrationTime;
}
public String getInfo(){
return "用户名：" + username + "，密码：" + password + "，注册时间：" + registrationTime;
}
}如果提取构造器公共代码到非静态代码块，User类是这样的：
public class User {
private String username;
private String password;
private long registrationTime;
{
System.out.println("新用户注册");
registrationTime = System.currentTimeMillis();
}
public User() {
username = registrationTime+"";
password = "123456";
}
public User(String username, String password) {
this.username = username;
this.password = password;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public long getRegistrationTime() {
return registrationTime;
}
public String getInfo(){
return "用户名：" + username + "，密码：" + password + "，注册时间：" + registrationTime;
}
}6.4.3 实例初始化过程（了解）
1、实例初始化的目的
实例初始化的过程其实就是在new对象的过程中为实例变量赋有效初始值的过程
2、实例初始化相关代码
在new对象的过程中给实例变量赋初始值可以通过以下3个部分的代码完成：
（1）实例变量直接初始化
（2）非静态代码块
（3）构造器
当然，如果没有编写上面3个部分的任何代码，那么实例变量也有默认值。
3、实例初始化方法
实际上我们编写的代码在编译时，会自动处理代码，整理出一个或多个的<init>(...)实例初始化方法。一个类有几个实例初始化方法，由这个类就有几个构造器决定。
实例初始化方法的方法体，由4部分构成：
（1）super()或super(实参列表)
-
这里选择哪个，看原来构造器首行是super()还是super(实参列表)
-
如果原来构造器首行是this()或this(实参列表)，那么就取对应构造器首行的super()或super(实参列表)
-
如果原来构造器首行既没写this()或this(实参列表)，也没写super()或super(实参列表) ，默认就是super()
（2）非静态实例变量的显示赋值语句
（3）非静态代码块
（4）对应构造器中剩下的的代码
特别说明：其中（2）和（3）是按顺序合并的，（1）一定在最前面（4）一定在最后面
4、实例初始化执行特点
-
创建对象时，才会执行
-
每new一个对象，都会完成该对象的实例初始化
-
调用哪个构造器，就是执行它对应的<init>实例初始化方法
-
子类super()还是super(实参列表)实例初始化方法中的super()或super(实参列表) 不仅仅代表父类的构造器代码了，而是代表父类构造器对应的实例初始化方法。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
