java基础学习_继承与多态_继承与多态中学习的内容-CSDN博客

本文链接：https://blog.csdn.net/qq_41663996/article/details/106934089

1 继承：

面向对象的三大特征：封装性，继承性，多态性
继承是多态的前提，没有继承就没有多态

* 在子父类的继承关系中，如果成员变量重名，则创建子类对象时，访问有两种方式：
	直接通过子类对象访问成员变量：等号左边是谁，就优先用谁，没有则向上找。
	间接通过成员方法访问成员变量：该方法属于谁，就优先用谁，没有则向上找。

* 子父类中定义重名变量：
	局部变量：直接写成员变量名
	本类中的成员变量：this.成员变量
	父类中的成员变量：super.成员变量

* 继承关系中，父子类构造方法访问特点:
	1 子类构造方法中有一个隐含的"super()"调用，所以一定是先调用父类构造，再调用子类构造
	2 子类构造中可以通过super关键字来调用父类的重载构造
	3 super的父类构造调用，必须是子类构造方法的第一个语句，不能一个子类构造调用多次父类构造

2 接口

接口就是多个类的公共规范
接口是一种引用数据类型，最重要的内容就是其中的：抽象方法
* 定义接口：
	public interface 接口名称{
			//接口内容
	}

* 如果是java7,接口中可以包含的内容：1 常量、2 抽象方法
* 如果是java8,还可以额外包含：3 默认方法、4 静态方法
* 如果是java9,还可以额外包含：5 私有方法


*从java 8开始,接口里允许定义默认方法
	public default 返回值类型  方法名称(参数列表){
		//方法体(默认方法可以有方法体)
	}
	备注：接口当中的默认方法，可以解决接口升级的问题
		1 接口的默认方法，可以通过接口实现类对象，直接调用
		2 接口的默认方法，也可以被接口实现类进行覆盖重写

接口中的默认方法是为了解决接口升级

public interface MyInterfaceDefault {
	public abstract void methodAbs();
	//新添加了一个抽象方法 --- 其他实现接口的类必须重写新方法，否则会报错
	//public abstract void methodAbs2();新方法添加导致其他实现类必须改动
	//解决:新添加的方法改为默认方法
	public default void methodDefault() {
		System.out.println("这是新添加的默认方法");  //默认方法可以有方法体
	}
}
//已经投入使用的两个实现类
public class MyInterfaceDefaultA implements MyInterfaceDefault{
	@Override
	public void methodAbs() {
		System.out.println("实现了抽象方法aaa");
	}
}
public class MyInterfaceDefaultB implements MyInterfaceDefault{
	@Override
	public void methodAbs() {
		System.out.println("实现了抽象方法bbb");
	}
	@Override
	public void methodDefault() {
		System.out.println("实现类B覆盖重写了接口的默认方法");
	}
}
//主方法
public class Demo2_InterfaceDefault {
	public static void main(String[] args) {
		MyInterfaceDefaultA a = new MyInterfaceDefaultA();  //创建实现类对象
		//调用默认方法，如果实现类当中没有，就会向上找接口
		a.methodDefault();  //直接调用默认方法
		System.out.println("----------------------------");
		MyInterfaceDefaultB b = new MyInterfaceDefaultB();  //创建实现类对象
		b.methodDefault(); //实现类B覆盖重写了接口的默认方法
	}
}
总结:我们不需要修改实现类A和B,直接可以使用继承接口中的默认方法.

*从java8开始，接口中允许定义静态方法
	public static 返回值类型  方法名称(参数列表){
		//方法体
	}
	提示：就是将abstract或者default换成static即可，带上方法体

public interface MyInterfaceStatic {
	public static void methodStatic() {
		System.out.println("这是接口的静态方法");
	}
}

注意:不能通过接口实现类的对象来调用接口的静态方法：一个类可以实现多个接口，所以多个接口中静态方法中可能会产生冲突
正确用法：通过接口名称，直接调用其中的静态方法

public class Demo3_InterfaceStatic {
	public static void main(String[] args) {
		//不能通过接口实现类的对象来调用接口的静态方法
//		InterfaceStaticImpl i = new InterfaceStaticImpl();
		
		//正确写法：
		MyInterfaceStatic.methodStatic(); //这是接口的静态方法
	}
}

从java9开始，接口中允许定义私有方法
	1 普通私有方法：解决多个默认方法间重复代码问题
		格式：private 返回值类型  方法名称(参数列表){
			//方法体
		}
	2 静态私有方法：解决多个静态方法间重复代码问题
		格式：private static 返回值类型  方法名称(参数列表){
			//方法体
		}
	

* 接口中也可以定义"成员变量"，但是必须使用public static final三个关键字进行修饰。
	从效果上看，这其实是接口的[常量]

	  格式：public static final 数据类型  常量名称 = 数据值
	  注意：一旦使用final关键字修饰，说明不可改变

	注意事项：
		1 接口中的常量可以省略public static final，但是不写也照样是这样
		2 接口当中的常量，必须进行赋值，不能不赋值	
		3 接口中的常量的名称，使用完全大写的字母，用斜划线进行分隔(推荐命名风格)

接口总结：在Java 9+版本中，接口的内容可以有:
	1.成员变量其实是常量，格式:
		[public] [static] [final]数据类型常量名称-数据值;
		注意:
		常量必须进行赋值。而且一旦赋值不能改变。
		常量名称完全大写，用下划线进行分隔。
	I
	2.接口中最重要的就是抽象方法，格式:
		[public] [abstract] 返回值类型方法名称(参数列表);
		注意:实现类必须覆盖重写接口所有的抽象方法，除非实现类是抽象类。
	
	3.从Java 8开始，接口里允许定义默认方法，格式: .
		[public] default 返回值类型方法名称(参数列表) {方法体}
		注意:默认方法也可以被覆盖重写
	
	 4.从Java 8开始，接口里允许定义静态方法，格式:
		[public] static 返回值类型方法名称(参数列表) {方法体}
		注意: 应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法
	
	
	5.从Java 9开始，接口里允许定义私有方法，格式:
		普通私有方法: private返回值类型方法名称(参数列表) {方法体}
		静态私有方法: private static 返回值类型方法名称(参数列表) { 方法体}
		注意: private的方法只有接口自己才能调用，不能被实现类或别人使用。
	
* 使用接口需要注意：
	1 接口是没有静态代码块或者构造方法的
	2 一个类的直接父类是唯一的，但是一个类可以同时实现多个接口
		格式：public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB{
			//覆盖重写所有抽象方法
		}
	3 如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可
	4 如果实现类没有覆盖重写所有接口当中所有抽象方法，那么实现类即必须是一个抽象类(和继承差不多)
	5 如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写
	6 一个类如果直接父类当中的方法，和接口当中的默认方法冲突，优先用父类当中的方法

* 接口之间的多继承
	1 类与类之间是单继承的，直接父类只有一个
	2 类与接口之间是多实现的，一个类可以实现多个接口
	3 接口与接口之间是多继承的
	
注意事项：	
	1 多个父接口当中的抽象方法如果重复，没关系(没有方法体)
	2 多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，而且要带default关键字

3 多态

* 代码当中体现多态性：其实就是一句话 --- 父类引用指向子类对象 （左父右子）
	格式：父类名称  对象名 = new 子类名称()
	或者：接口名称  对象名 = new 实现类名称()
	
  * 访问成员变量的两种方式：
	1 直接通过对象名称访问成员变量，看等号左边是谁，优先用谁，没有则向上找
	2 间接通过成员方法访问成员变量，看该方法属于谁，优先用谁，没有则向上找

  * 在多态的代码中，访问成员方法的规则是：看new的是谁，就优先用谁，没有则向上找
	

  * 口诀：
	  成员变量：编译看左边，运行还看左边
	  成员方法：编译看左边，运行看右边

* 对象的向上转型：其实就是多态写法
	格式：父类名称 对象名 = new 子类名称()  				Animal animal = new Cat();
	含义：右侧创建一个子类对象，把它当做父类来看待使用		创建了一只猫，当做动物看待
	* 注意：向上转型一定是安全的 //从小范围转向了大范围，从小范围的猫转向更大范围的动物
	
	* 弊端：对象一旦向上转型成父类，那么就无法调用子类原本特有的内容
		解决：用对象的向下转型[还原]

* 对象的向下转型：其实是一个还原的动作
		格式：子类名称 对象名 = (子类名称)父类对象
		含义：将父类对象，[还原]成为/本来/的子类对象
		Animal animal = new Cat();//本来是猫，向上转型成为动物
		Cat cat = (Cat)animal;  //本来是猫，已经被当做动物了，还原回来成为本来的猫
		* 注意：a 必须保证对象本来创建的时候，就是猫，才能向下转型成为猫
				b 如果对象创建的时候本来不是猫，现在非要向下转型成为猫，就会报错 //类转换异常ClassCastException
				类似于：int num = (int)10.0; //可以
						int num = (int)10.5; //不可以，精度损失

案例：笔记本usb接口案例

接口
public interface USB {
	public abstract void open();  //打开设备
	public abstract void close(); //关闭设备
}

实现类
//键盘是一个USB设备
public class Keybox implements USB{
	@Override
	public void open() {
		// TODO Auto-generated method stub
		System.out.println("打开键盘");
	}
	@Override
	public void close() {
		// TODO Auto-generated method stub
		System.out.println("关闭键盘");
	}
	public void type() {
		System.out.println("键盘输入");
	}
}
//鼠标是一个USB设备
public class Mouse implements USB{
	@Override
	public void open() {
		// TODO Auto-generated method stub
		System.out.println("打开鼠标");
	}
	@Override
	public void close() {
		// TODO Auto-generated method stub
		System.out.println("关闭鼠标");
	}
	public void click() {
		System.out.println("鼠标单击");
	}
}

定义一个电脑类
public class Computer {
	public void powerOn() {
		System.out.println("笔记本电脑开机");
	}
	public void powerOff() {
		System.out.println("笔记本电脑关机");
	}
	//使用usb设备的方法,使用接口作为方法参数
	public void useDevice(USB usb) {
		usb.open();
//		usb.click();  设备特有
		if(usb instanceof Mouse) {  //一定要先判断
			Mouse mouse = (Mouse) usb;  //向下转型
			mouse.click();
		}else if(usb instanceof Keybox){
			Keybox keybox = (Keybox) usb;
			keybox.type();
		}
		usb.close();
	}
}

主方法
public class DemoMain {
	public static void main(String[] args) {
		//创建一个笔记本电脑
		Computer computer = new Computer();
		computer.powerOn();	 //开机
		//准备一个鼠标
//		Mouse mouse = new Mouse(); 
		//首先进行向上转型
		USB usb_mouse = new Mouse();   //多态写法
		computer.useDevice(usb_mouse);  //参数是usb类型，传递参数
		//创建一个usb键盘
		Keybox keybox = new Keybox(); //没有使用多态写法
		//方法参数是usb类型，传递进入的参数是实现类对象
		computer.useDevice(keybox);  //正确写法！也发生了向上转型
//		computer.useDevice(new Keybox());   //也是正确写法  keybox --> usb
		computer.powerOff();  //关机
	}
}