20200929

20200929

知识点总结

多态

一个特定类型的变量，可以引用多个不同类型的对象，并且能自动调用引用对象的方法。也就是
说根据引用对象的不同，响应不同的操作。

package com.itlaobing.exe;
//父类Pet
public class Pet {
    //父类方法
	public void toHospital() {
		System.out.println("宠物去看病");
	}
}

package com.itlaobing.exe;
//子类Dog继承父类Pet
public class Dog extends Pet{
    //重写父类方法
	public void toHospital() {
		System.out.println("小狗去看病");
	}
	public void catchingFlyDisc() {
		System.out.println("小狗接飞盘");
	}
}

package com.itlaobing.exe;
//子类Bird继承父类Pet
public class Bird extends Pet {
    //重写父类方法
	public void toHospital() {
		System.out.println("小鸟去看病");
	}
	public void fly() {
		System.out.println("小鸟飞翔");
	}
}

package com.itlaobing.exe;

import java.util.Scanner;

//测试类PetTest
public class PetTest {
	public static void main(String[] args) {
		System.out.println("请输入想要的宠物，1：小狗  2：小鸟");
		Scanner input = new Scanner(System.in);
		int choice = input.nextInt();
		Pet pet = null ;
        //向上转型
		switch(choice) {
		case 1:
			pet = new Dog();//如果选1，父类引用指向子类Dog
			break;
		case 2:
			pet = new Bird();//如果选2，父类引用指向子类Bird
			break;
		}
		pet.toHospital();
        //向下转型
		if(pet instanceof Dog) {//判断pet指向的是否是Dog类
			Dog dog = (Dog) pet;//将pet转为Dog型
			dog.catchingFlyDisc();//调用Dog类的新方法
		}
		if(pet instanceof Bird) {
			Bird bird = (Bird) pet;
			bird.fly();
		}
	}
}
//输出结果：
//请输入想要的宠物，1：小狗  2：小鸟
//1
//小狗去看病
//小狗接飞盘

向上转型：由子类类型转换成父类类型，称为向上转型。父类引用指向子类对象

//父类类型 变量 = 子类类型实例;
Pet pet = new Dog();//向上转型

多态就是说一个父类可能有多个子类，每个子类都重写了父类的方法（每个子类都有不同的方法实
现），当父类调用方法时，父类引用指向的是哪个子类，就执行哪个子类的方法。形成了父类引用调用
相同的方法时，有不同的实现。

• 父类引用只能调用父类中有的方法（子类继承自父类的方法/重写的方法）
• 父类引用不能调用子类扩展的方法（独有的方法）

**向下转型：**由父类类型转换成子类类型，称为向下转型。必须要进行强制类型转换。

上面说到，当向上转型发生后，父类不能调用子类新增的方法。但是如果想要调用子类新增的方法，可以通过把父类转换为子类实现。

注意：首先要判断是否属于要强转的类型( instanceof )，如果不属于会报java.lang.ClassCastException

如上面的例子Dog类包含一个接飞盘的方法catchingFlyDisc()，就需要向下转型实现。

Dog dog = (Dog) pet;//将Pet型转换为Dog型
dog.catchingFlyDisc;//调用了Dog新增的方法

实现多态的条件：

• 要有继承关系
• 父类引用指向子类对象（向上转型)
• 子类要重写父类的方法

抽象类

从上面多态的代码可以看出，父类中toHospital()的方法没有实际意义。

但删除之后会报错，失去了多态的特征。

abstract：在 java 中，被 abstract 关键字修饰的类叫做抽象类，被 abstract 关键字修饰的方法叫做抽象方法。
抽象方法是没有具体实现（没有方法体）的。 abstract 不能和 final 一起使用。

抽象方法和普通方法的区别：

[修饰符] 返回值类型 方法名([参数列表]){ //普通方法
//方法体
}
[修饰符] abstract 返回值类型 方法名([参数列表]); //抽象方法
/抽象类
public abstract class Pet {
//抽象方法
public abstract void toHospital();
}

我们看到，抽象方法没有具体的实现（没有方法体），所以，抽象不能执行。
抽象方法是由继承了抽象类的子类重写后调用子类重写的方法来执行。

抽象类和普通类的区别：

抽象类中可以有普通方法
如果一个类继承了抽象类，那么这个类必须重写它的抽象方法，或者将类声明为抽象类
抽象类是有构造方法的，但是不能被实例化。
构造方法、类方法( static )不能声明为抽象( abstract )方法
区别：
抽象类有 abstract 修饰，
抽象类中可以有抽象方法，
抽象类不能被实例化，需要抽象类变量引用其子类的对象
抽象类除了不能被实例化以外，和普通了类没有区别。定义抽象类是为了强迫子类实现抽象方
法，是定义规范的
一个类中只要含有抽象方法，这个类就必须是抽象类;抽象类不一定含有抽象方法

接口

约定好规范，然后按照规范来做。接口就是定义规范。
java 中的接口作用和生活中类似，它提供一种约定，使实现接口的类在形式上保持一致。
抽象类中可以有普通方法而接口中的方法都是抽象的，也可以说接口是一个特殊的 抽象类 ，接口不能被
实例化，而且没有构造方法。

定义接口

[修饰符] interface 接口名{
//接口成员
}
public interface USBInterface {
public static final String NAME = "";//静态常量
public void service();
}

接口中的方法默认是抽象方法，所以可以省略 abstract 修饰符
接口中的方法默认都是 public 的，所以可以省略 public
接口中的变量只能是静态常量( static final ),所以可以省略 static final ，静态常量在定义时就要
赋值，且不可变。

1. 抽象方法有 abstract 修饰，
2. 抽象方法没有方法体，
3. 抽象方法无法执行，
4. 抽象方法不能用 private 修饰，

今日总结：

感觉每天学的东西都有点多，脑子里很乱。晚自习虽然把作业给运行出来了，但还是不能很明白原理，第一题题目要求的Circle 类的构造方法中需要调用父类有参构造设置其类型 ( 将 type 设置为 "圆" 即可 )不是很明白，就在父类用了getset方法调用type。