day03(接口，多态)

 接口：
            概念：是功能的集合,可以当做引用数据类型的一种。比抽象类更加抽象。

     接口的成员：
               成员变量:必须使用final修饰 默认被 public & static & final修饰 不允许修改

               成员方法:必须是抽象方法 默认是抽象方法 创建方法时可以省略。（开发时建议写上，好辨识）
              构造方法:没有
　　

public interface Inter01 {
	public static final int NUM=10;
	public abstract void eat();

       特点：

             　1.打破了常规的单继承，接口可以多继承，也可以多层继承

                 2.成员方法都是抽象方法，成员变量必须被final修饰。

  　   　   3.不能创建对象（因为接口里面都是抽象方法，调用没有意义）
　　　　 4.子类必须实现所有成员方法。

public interface Inter01 {
	public static final int NUM=10;
	public abstract void eat();
	public abstract void sleep();
}
interface Inter03{
}
//体现了多继承  打破了类的单继承
interface Inter02 extends Inter01,Inter03{	
}
class Test implements Inter01{//实现接口的所有方法
	@Override
	public void eat() {
	}
	@Override
	public void sleep() {
	}
}

　　

   接口和类的关系
　　　　 A:类与类之间:继承关系,一个类只能直接继承一个父类,但是支持多重继承
　　　　 B:类与接口之间:只有实现关系,一个类可以实现多个接口
　　　　 C:接口与接口之间:只有继承关系,一个接口可以继承多个接口
　 接口的优点
　　　　 1.类与接口的关系，实现关系，而且是多实现，一个类可以实现多个接口，类与类之间是继承关系，java中的继承是单一继承，一个类只能有一个父类，打破了继承的局限性。
　　　　 2.对外提供规则（USB接口）    

　　　　 3.降低了程序的耦合性（可以实现模块化开发，定义好规则，每个人实现自己的模块，提高了开发的效率）

                      

多态：

　　　概念：父类在不同的时候表现出不同的状态。

　　　实现多态的前提：1.继承

　　　　　　　　　　　2.重写

　　　　　　　　　　　3.父类引用指向子类对象

　　　实现多态的三种格式

　　　　　　普通类实现多态

class Fu{
	public void eat(){
		System.out.println("Fu 吃饭");
	}
}
class Zi extends Fu{
	@Override
	public void eat(){
		System.out.println("Zi 吃饭");
	}
}
public class Inter01{
	public static void main(String[] args) {
		Fu f=new Zi();//父类引用指向子类对象
		f.eat();//Zi 吃饭
	}
}

　　　　　　抽象类实现多态

abstract class Fu{
	public abstract void method();
}
class Zi extends Fu{
	@Override
	public void method(){
		System.out.println("子类重写了父类的方法method");
	}
}
public class Inter01{
	public static void main(String[] args) {
		Fu f=new Zi();//父类引用指向子类对象
		f.method();//子类重写了父类的方法method
	}
}

　　　　　　接口实现多态

interface Inter02{
	public abstract void jump();
}
class Cat implements Inter02{
	public void jump() {
		System.out.println("猫可以调高");
	}
}
class tiger implements Inter02{

	@Override
	public void jump() {
		System.out.println("老虎会调高");
	}
	
}
public class Class01{
	public static void main(String[] args) {
		Inter02 i=new tiger();
		i.jump();
	}
}

　　多态的成员特点

　　　　       成员变量：  仅仅只是该事物的外在特征描述

　　　　　　　　　　编译时看左边  运行时看左边

　　　　　　成员方法：  功能描述 　　　　

　　　　　　　　　　编译时看左边　运行数看右边

　　　　 　  静态方法：不能被重写

　　　　　　　　　　编译时看左边  运行时看左边

　　

public class PoymorphicDemo2 {
	public static void main(String[] args) {
		Dad d = new Kid();
		//System.out.println(d.num);
		
		//d.method();
		d.function();//使用变量去调用静态方法，其实相当于用变量类型的类名去调用
	}
}

class Dad {
	int num = 20;
	
	public void method() {
		System.out.println("我是父类方法");
	}
	
	public static void function() {
		System.out.println("我是父类静态方法");
	}
}

class Kid extends Dad {
	int num = 10;
	
	public void method() {
		System.out.println("我是子类方法");
	}
	
	public static void function() {
		System.out.println("我是子类静态方法");
	}
}

　　多态中的向上转型和向下转型

　　　　　　向上转型　　自动转型

　　　　　　　　　　　　父类     父=new   子类();

　　　　　　向下转型　　　子类   子=（子类）父；

　　　　　　举例：孔子装爹

　　　　　　　　向上转型     孔子装他爹

　　　　　　　　向下转型     孔子脱了衣服

/*
 *	
 * 	多态中的向上转型和向下转型:
 * 
 *  引用类型之间的转换
 *  	向上转型
 *  		由小到大(子类型转换成父类型)
 *  	向下转型
 *  		由大到小
 *  基本数据类型的转换
 *  	自动类型转换
 *  		由小到大
 *  		byte short char --- int --- long --- float --- double
 *  	强制类型转换
 *  		由大到小
 *  		
 * 	
 * 
 */
public class PoymorphicDemo3 {
	public static void main(String[] args) {
		Animal2 a = new Dog();//向上转型
		//a.eat();
		
		Dog d = (Dog)a;//向下转型
		d.swim();
		
	}
}

class Animal2 {
	public void eat() {
		System.out.println("吃东西");
	}
}


class Dog extends Animal2 {
	public void eat() {
		System.out.println("啃骨头");
	}
	
	public void swim() {
		System.out.println("狗刨");
	}
}

　　

 多态内存图

                

　　　　类转化异常