多态、抽象、接口的一些总结

1.多态

• 1.多态概述
  同一个引用类型，使用不同的实例而执行不同操作，即父类引用指向子类对象。
• 2.实现多态的必要条件
  （1） 有继承关系
  （2）有方法重写
  （3）运行时使用父类的引用子类的对象
• 3.多态的优缺点
• 多态的优点：
  （1）提高了程序的维护性
  （2）提高了程序的扩展性
• 多态的缺点：
  不能访问子类所特有的功能
  解决办法：向下转型
  向下转型：（可理解为基本数据类型中的强制转换）
  格式：<子类型> <引用变量名> = (<子类型> )<父类型的引用变量>;

		Car c = new BMW();
		c.run();		
		// 想要访问BMW的fillOil,无法访问
		// 利用向下转型
		BMW bmw = (BMW) c;
		bmw.fillOil();

特点：
父类转为子类，父类引用转为子类对象。理解为强制类型转换
在向下转型的过程中，如果没有转换为真实子类类型，会出现类型转换异常(java.lang.ClassCastException) 解决办法: 在每次向下转型之前做一个类型的判断
类型判断的语法: instanceof
左边对象 instanceof 类名 这个表达式的结果是boolean类型
测试它左边的对象是否是它右边的类的实例

  if (c instanceof Benz) {
			Benz benz = (Benz) c;
			benz.leakOli();
		} else if (c instanceof BMW) {
			BMW b = (BMW) c;
			b.fillOil();
	} else  if (c instanceof BYD) {
			BYD byd = (BYD) c;
			byd.electric();
		}

• 4.多态访问成员的特点:
• 成员变量: 编译时期看左边的类型,如果左边类型中没有变量,编译报错
  运行时期看左边类型,左边类型的变量的值就是运行的结果
  编译看左边,执行看左边
• 成员方法:
  编译看左边,执行看右边
• 构造方法:
  多态访问子类构造方法会先访问父类构造方法
  帮助子类初始化父类继承过来的成员
• 静态方法:
  编译看左边,执行看左边

public class Demo1 {
	public static void main(String[] args) {
		Fu fu = new Zi();
		System.out.println(fu.num); //结果为10
		fu.method();				//结果为Zi.method()
		fu.show();					//结果为Fu.show
	}
}
class Fu {
	int num = 10;
	public void method() {
		System.out.println("Fu.method()");
	}	
	public static void show() {
		System.out.println("Fu.show");
	}
}
class Zi extends Fu {
	int num = 20;
	@Override
	public void method() {
		System.out.println("Zi.method()");
	}	
	public static void show() {
		System.out.println("Zi.show");
	}	
}

2.抽象类

• 1.抽象类概述：
  被abstract关键字所修饰的类被称为抽象类。
  在Java中，如果一个没有方法体，没有实现的方法定义为抽象方法，一个类中一旦出现抽象方法，该类一定是一个抽象类。
• 2.格式
  abstract class 类名 {}

public abstract double getArea() ;

• 3.注意事项
  • 抽象方法和抽象类使用 abstract 修饰
  • 有一个抽象方法的类必须是抽象类
  • 抽象类中一定有抽象方法吗? --> 不一定
  • .没有抽象方法的抽象类有意义? --> 有意义,防止外界创建对象
  • 防止外界实例的方式:
    • a.构造方法私有
    • b.抽象类
    • c.接口
    • d.内部类
  • 抽象类不能够实例化 – 利用多态
  • 抽象类的子类的特点:
    a.如果子类想要继承抽象类,就必须实现抽象类中所有的抽象方法
    b.如果子类不想实现父类的抽象方法,那么子类必须升级为抽象类
  • 抽象类和普通类的区别
  • 抽象类中可以有成员变量,成员方法,构造方法,静态方法,常量? 有的话又有什么意义呢?
    成员变量 --> 给子类使用
    成员方法 --> 给子类使用
    构造方法 --> 帮助子类初始化父类继承下来的成员
    静态方法 --> 直接通过类名访问,防止创建对象的不建议访问方式
    常量 --> 可以,方便访问
    抽象类和普通类没有区别,只不过是抽象类多了抽象方法而已
    抽象类的抽象方法强制子类重写
    非抽象方法直接给子类使用
    构造方法和成员变量直接给子类使用
• 抽象类是一个彻头彻尾的服务类,服务于所有的子类
• .抽象类的成员一般使用 public 或者 protected
• .private final static native 可以用来修饰抽象方法吗?
  private修饰的方法不能够被子类继承,更不可能被重写,abstract修饰的方法强制子类重写,二者冲突
  final修饰的方法不能够被子类继承,更不可能被重写,abstract修饰的方法强制子类重写,二者冲突
  static修饰的方法一般方便调用,一般都是用来实现功能的,抽象方法没有方法体,二者没有意义
  native修饰的方法不是Java实现的,有方法体,抽象方法没有方法体,二者没有意义
• 4.static、final、abstract比较
  

3.接口

• 1概述：
  从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和抽象方法的定义，而没有变量和方法的实现。
  1.接口是一种标准,是一种规范,是一种约定
  2.接口可以扩展功能
  3.接口是灵活的,可以即插即拔
  4.接口由继承者来实现
• 2.格式

1. 接口的格式

public interface 接口名{
         常量
         抽象方法
  }

2. 接口的实现类格式:

 * 	public 类名  implements 接口{
 *     		实现接口的方法
 *     		普通方法
 *	}

• 3.接口的特点:
  1.接口使用interface修饰
  2.接口是常量和抽象方法的集合
  常量: 默认使用 public static final
  方法: 默认使用 public abstract修饰
  3.在JDK1.8以后不仅仅只有常量和抽象方法,还有默认方法和静态方法
  默认方法用来直接给子类使用,如果子类想重写也可以自行根据需求重写,不会强制重写
  静态方法用来直接通过接口名访问
  4.接口不能够实例化
  5.接口如果想要实例化–利用多态
  6.接口的实现类特点:
  a.如果一个类想要实现一个接口就必须实现接口中定义的所有抽象方法
  b.如果一个类不想实现接口中的抽象方法,那么实现类也升级为接口

 */
 package com.sxt.interfacedemo;
/*
public class InterfaceDemo01 {
	public static void main(String[] args) {
//		System.out.println(Inter.num);
		
//		Inter.num = 200;
		
//		Inter.staticMethod();
		
//		Inter inter = new Inter();
		
//		利用多态
		Inter inter = new InterImpl();
	}
}
interface Inter {
//	int num = 100;
	public static final int NUM = 100;	
	void show();	
	void method();	
	// 默认方法
	public default void defaultMethod() {
		System.out.println("Inter.defaultMethod()");
	}	
	// 静态方法
	public static void staticMethod() {
		System.out.println("Inter.staticMethod()");
	}
}
class InterImpl implements Inter {
	@Override
	public void show() {
		System.out.println("InterImpl.show()");
	}
	@Override
	public void method() {
		System.out.println("InterImpl.method()");
	}	
}
interface InterSon extends Inter {
	
}

• 4.接口和抽象类的区别