JAVA初窥-DAY15

动态绑定

动态绑定，也叫运行时绑定，表示编译代码时调用的方法与运行时调用的方法不一样。
动态绑定发生的前提：
一定要发生向上转型（父类引用要引用子类对象）
父类和子类有同名的（覆盖/重写/覆写）方法
通过父类的引用来调用这个同名的重写方法。此时就会发生动态绑定。
在构造方法中，也可以发生动态绑定！！！（一个坑）

class A{
    public A (String name){
    	this.name = name ;
    }
    public void eat(){
		System.out.println(A + name + "eat！！");
	}
}
class B extends A{
    public B (String name){
    	super(name);
    	this.name = name ;
    }
    public void eat(){//此时这个方法就叫重写方法。
		System.out.println(B + name + "eat！！");
	}
	public void fly(){
		System.out.println(B + name + "fly！！");
}
public class Test{
    public static void main(String[] args){
        A a = new B("lit");
        a.eat();//动态绑定，此时编译时，认为调用的是A的eat方法，但在运行时调用的时B的eat方法。
        // a.fly(); 调用异常 A类型没有fly方法
        
    }
} 

方法的重写

方法的重载 overload
方法的重写：override
方法名相同、
返回值相同(如果返回值时父子关系时，也时可以的)、
参数列表相同、（个数、类型）
如果当前方法是静态方法，是不可以被重写的；方法名不同，也不可以被重写；重写方法时，访问修饰符的权限一定要大于等于父类，父类中要被重写的方法的访问权限不可以为private；如果返回值构成协变类型，也就是返回值是继承关系的类型，也是可以发生重写的。
final修饰的方法不能被重写，叫密封方法。

class A{
    public void eat(){
		System.out.println(A + name + "eat！！");
	}
}
class B extends A{
    public void eat(){//此时这个方法就叫上面eat方法的重写方法。
		System.out.println(B + name + "eat！！");
	}
}

多态

一种事物，多种形态（只供理解）
也就是通过一种方法或者一个调用，可以实现不同的功能，如：

class A{
    public void act(){
	}
}
class B extends A{
    public void act(){
		System.out.println("站！！");
	}
}
class C extends A{
    public void act(){
		System.out.println("坐！！");
	}
}
public class Test{
	public static void idea(A a){
        a.act();
    }
    public static void main(String[] args){
        B b = new B();
        C c = new C();
        idea(b);//此时输出 站！！
        idea(c);//此时输出 坐！！
        idea(new B());//此时输出 站！！
        idea(new C());//此时输出 坐！！
    }
} 

抽象类

包含抽象方法的类就叫抽象类，而抽象方法就是被abstract修饰的方法，这个方法可以没有具体的实现；抽象类可以被继承、向上转型，动态绑定，抽象方法也可以被重写。抽象类不可以被实例化。一旦有某个类继承了抽象类，那么这个类一定要重写抽象类里的抽象方法。抽象类存在的意义就是为了被继承。如果抽象类被抽象类继承，那么不需要重写抽象方法，但是子类若有不是抽象类的类，则要重写所有父类的抽象方法。抽象类中的普通方法的调用需要用子类的对象去调用。

abstract class A{//不能实例化
    public abstract void act();
}
abstract class B extends A{//不能实例化
    public abstract void sleep();//此处因为时抽象类，不必重写父类的抽象方法
}
class C extends B{//要重写父类所有的抽象方法
    public void act(){
		System.out.println("坐！！");
	}
	public void sleep(){
		System.out.println("睡！！");
	}
}

接口

用interface 接口 修饰
接口当中的方法，默认是public abstract的，不能有具体的实现。
接口当中的属性，默认是public static final的，
接口不能实例化
类和接口的直接关系是implements 实现，此时接口当中的所有方法，都要被重写
接口也可以发生向上转型，运行时绑定。
jdk1.8开始，接口中的方法也可以有具体的实现，但必须加default修饰
在java中，一个类可以实现多个接口
接口的出现是为了满足多继承
接口与接口之间的关系是extends
两个类联系一个接口

interface IA{//接口不能实例化，接口命名加I 表示此类是接口
    void act();
    default void sleep(){
        System.out.println("睡！！");//此方法子类对象也可以用	
    }
}
class B implements IA {
    public void act() {
        System.out.println("站！！");
    }
}

class C implements IA {
    public void act() {
        System.out.println("坐！！");
    }
}
public class Test{
	public static void main(String[] args){
		IA a = new B();
		a.act();//此时向上转型，调用B中的act方法
	}	
}

一个类联系两个接口

interface IA {
    void act();
}
interface IB {
    void sleep();
}
class C implements IA , IB {//C类实现接口IA IB
    public void act() {
        System.out.println("坐！！");
    }
    public void sleep() {
        System.out.println("睡！！");
    }
}
public class Test{
    public static void main(String[] args){
       IA a = new C();
       a.act();
       //a.sleep(); 此时报错，因为IA接口中没有sleep方法
       IB b = (IB)a;
       b.sleep();
       C c = new C();
       c.sleep();
    }
}

接口扩展

interface IA {
    void act();
}
interface IB {
    void sleep();
}
interface IC extends IB，IA {
    void eat();
}
class C interface IC{
	public void act(){
		System.out.println("坐！！");
	}
	public void sleep(){
		System.out.println("睡！！");
	}
	public void eat(){
		System.out.println("吃！！");
	}
}

接口实例

class Person{
	public String name;
	public Person(String name){
		this.name = name;
	}
}
interface ISleep {
	void sleep();
}
interface ITeach {
	void teach();
}
interface IStudy {
	void study();
}
class Man extends Person implements ISleep{
	public Man(String name){
		super(name);
	}
	public void sleep(){
		System.out.println("睡！！");
	}
}
class Teacher extends Person implements ISleep,ITeach{
	public Teacher(String name){
		super(name);
	}
	public void teach(){
		System.out.println("教！！");
	}
	public void sleep(){
		System.out.println("睡！！");
	}
}
class Student extends Person implements ISleep,IStudy{
	public Student(String name){
		super(name);
	}
	public void study(){
		System.out.println("学！！");
	}
	public void sleep(){
		System.out.println("睡！！");
	}
}
public class Test{
    public static void act (ISleep iSleep){
        iSleep.sleep();
    }
    public static void main(String[] args){
       Student student = new Student("lit");
       student.study();
       student.sleep();
       act(new Man("lit1"));

    }
}

PS：接口和抽象类虽然不能实例化，但是接口与抽象类这个类型还是存在的，如：

interface A {
    public void work();
}
class B implements A{
    @Override
    public void work() {
        System.out.println("qqqq");
    }
}
public class Demo02{
    public static void main(String[] args) {
        A[] a = new A[]{new B()};
        a[0].work();
    }
}