Final和接口

变量：常量 一旦赋值 不可改变

        final修饰属性的时候 该属性就没有默认值 就必须手动赋值

方法：final方法不能被子类覆盖

类：final类不能被继承

private 属性 方法  构造方法

（default） 属性 方法  构造方法  类

protected 属性 方法  构造方法 

public 属性  方法  构造方法  类

private abstract  不能联用

final abstract 不能联用

static abstract  不能联用

 

接口：特殊的抽象类

1.属性都是公开静态常量

2.方法都是公开抽象方法

3.没有构造方法

  实现接口 implements

一个类实现接口，如果这个类不希望成为抽象类，就必须实现接口中的所有抽象方法

public class TestInterface {
	public static void main(String[] args) {
		IA a = new Myclass();
		a.m1();
		a.m2();
	}
}

abstract class ClassA{
	public static final int A = 10;
	public static final double B = 3.8;
	public abstract void m1();
	public abstract void m2();
	public ClassA() {}
}
//接口
interface IA{
	int A = 10;
	double B = 3.8;
	void m1();
	void m2();
}
//implements 实现
class Myclass implements IA{
	public void m1() {};
	public void m2() {};
}

接口之间可以定义多继承关系

一个类在继承另外一个类的同时 还能实现多个接口

interface IB{
	void m3();
}
interface IC{
	void m4();
}
interface ID extends IB,IC{
	void m5();
}
abstract class ClassE{
	public abstract void m6();
}
class MyClass extends ClassE implements IA,ID{
	public void m1() {}
	public void m2() {}
	public void m3() {}
	public void m4() {}
	public void m5() {}
	public void m6() {}
}
main方法里去实例调用  最后访问的都是继承的myclass类
MyClass mc = new MyClass();
		IA a=mc;
		IB b = mc;
		IC c = mc;
		ID d = mc;
		ClassE e = mc;
		a.m1();
		a.m2();
		b.m3();
		c.m4();
		d.m3();
		d.m4();
		d.m5();
		e.m6();