Java基础-----多态

/*


面向对象的三大特征：


    1.封装
2.继承
3.多态


多态：一个对象具备多种形态。（父类的引用类型变量指向了子类的对象
或者接口的引用类型变量指向了接口实现类的对象）
多态的前提：必须存在继承或者实现关系。


老钟  老师
老钟  员工
老钟  路人甲
老钟  老公


动物 a = new 狗();


多态要注意的而细节：


    1.多态的情况下，子父类存在同名的成员变量时，访问的是父类的成员变量
2.多态情况下，子父类存在同名的非静态的成员函数时，访问的是子类的成员函数。
3.多态情况下，子父类存在同名的静态的成员函数时，访问的是父类的成员函数。
    4.多态情况下，不能访问子类特有的成员。


总结；多态情况下，子父类存在同名的成员时，访问的都是父类的成员，除了在同名非静态的成员函数时，访问的是子类的成员函数
编译看左边，运行不一定看右边。


编译看左边：Java编译器在编译的时候，会检查引用类型变量所属的类是否具备指定的成员，如果不具备马上报错。




*/




abstract class Animal
{
String name;
String color = "动物色";
public Animal(String name){
this.name  =name;

}


public abstract void run();
public void eat(){
System.out.println("动物在吃饭");

}


}


//老鼠


class Mouse extends Animal 
{
String color = "黑色";
public Mouse(String name){
super(name);


}

public void run(){
System.out.println(name+"四条腿慢慢的走");
}
public void eat(){
System.out.println("老鼠在偷吃");

}


//老鼠特有的方法--打洞
public void dig(){
System.out.println("老鼠在打洞");

}
}


class Fish extends Animal
{
public Fish(String name){
super(name);

}

public void run(){
System.out.println(name+"四条腿慢慢的走");
  }
}
class Demo11 
{
public static void main(String[] args) 
{
/*

Mouse m= new Mouse("老鼠");
m.run();
System.out.println(m.color);


多态：父类的引用类型变量指向子类的对象
*/

Animal a = new Mouse("老鼠");
a.run();
a.eat();
a.dig();
System.out.println(a.color);


}

}

/*
多态的应用：
    1.多态用于形式参数类型的时候，可以接收更多类型的数据。
2.多态用于返回值类型的时候，可以返回更多类型的数据


多态的好处：提高了代码的拓展性
需求1：定义一个函数可以接收任意类型的图形对象，并且可以打印图形面积与周长。
*/




//图形类


abstract class MyShape
{
public abstract void getArea();
public abstract void getLength();
}


class Circle extends MyShape
{
public static final double PI = 3.14;
double r;


public Circle(double r){
this.r = r;

}


public void getArea(){
System.out.println("圆形的面积"+PI*r*r);

}


public void getLength(){
System.out.println("圆形的周长"+2*PI*r);

}
}


class Rect extends MyShape
{
int width;
int height;


public Rect(int width,int height){
this.width = width;
this.height = height;

}
public void getArea(){
System.out.println("矩形面积"+width*height);

}
public void getLength(){
System.out.println("矩形周长："+2*(width+height));

}
}
class Demo12 
{
public static void main(String[] args) 
{
/*
Circle c  = new Circle(4.0);
print(c);
Rect r = new Rect(3,4);
print(r);
*/


MyShape m =getShape(1);//调用了使用多态的方法，定义的变量类型要与返回值类型一致。
m.getArea();
m.getLength();
}


//需求1：定义一个函数可以接收任意类型的图形对象，并且可以打印图形面积与周长。


public static void print(MyShape s){//MyShape s= new Circle（4.0）
s.getArea();
s.getLength();

}


//需求1：定义一个函数可以返回任意类型的图形对象。
public static MyShape  getShape(int i){
if (i==0)
{
return new Circle(4.0);
}else{
return new Rect(3,4);
}

}
}

/*
目前多态情况下不能访问子类特有的成员


如果需要访问子类特有的成员，那么需要进行类型强制转换




基本数据类型的转换


小数据类型------>大的数据类型     自动类型转换


大数据类型------->小数据类型       强制类型转换     小数据类型  变量名 = （大数据类型）




引用数据类型的转换


小数据类型------------>大数据类型    自动类型转换


大数据类型----------->小数据类型      强制类型转换


强制类型转换最常见的异常：java.lang.ClassCastException  强制类型转换失败
*/
abstract class Animal
{
String name;

public Animal(String name){
this.name  =name;

}


}


//老鼠


class Mouse extends Animal 
{

public Mouse(String name){
super(name);


}

public void run(){
System.out.println(name+"四条腿慢慢的走");
}
public void eat(){
System.out.println("老鼠在偷吃");

}


//老鼠特有的方法--打洞
public void dig(){
System.out.println("老鼠在打洞");

}
}


//鱼
class Fish extends Animal
{
public Fish(String name){
super(name);

}


public void run(){
System.out.println(name+"摇摇尾巴游啊游");
}
    public void bubble(){
System.out.println(name+"吹泡泡");
}

}


class Demo2 
{
public static void main(String[] args) 
{
/*
Animal a = new Mouse("老鼠");//多态
Mouse m = (Mouse)a;//强制类型转换
//调用子类特有的方法
m.dig();
*/


Mouse m = new Mouse("米老鼠");
Fish f = new Fish("草鱼");
print(f);


}




//需求：定义一个函数可以接收任意类型的动物对象，在函数内部要调用到动物特有的方法。


public static void print(Animal a){//Animal a = new Mouse("米老鼠");
if (a instanceof Fish)
{
Fish f = (Fish)a;
f.bubble();
}else if (a instanceof Mouse)
{
Mouse m = (Mouse)a;
m.dig();
}



}
}

/*


多态：父类的引用类型变量指向了子类的对象或者接口类型的引用类型变量指向了接口实现类的对象。




实现关系下的多态


接口  变量 = new 接口实现类的对象。




*/


interface Dao//接口的方法全部都是非静态的方法
{
public void add();
public void delete();
}
//接口的实现类


class UseDao implements Dao
{
public void add(){
System.out.println("添加员工成功");

}


public void delete(){
System.out.println("删除员工成功");

}
}
class Demo3 
{
public static void main(String[] args) 
{
//实现关系下的多态


Dao d = new UseDao();//接口的引用变量指向了接口实现类的对象
d.add();
}
}

复习

/*
抽象类：


什么时候使用抽象类：


    描述一类事物的时候，发现该事物确实存在着某种行为，但是目前这种是不具体的，
这时候应该抽取这种行为的声明，而不去实现这种行为，这时候这种行为我们把它
称为抽象的行为，这时候应该使用抽象类


抽象类要注意的细节：
    1.如果一个方法没有方法体，那么该方法必须使用abstract修饰
2.如果一个类函数抽象方法，那么这个类肯定是一个抽象类或者接口。
3.抽象类不能创建对象。
4.抽象类是含有构造方法的。
5.抽象类可以含有非抽象方法与抽象方法。
6.抽象类可以不存在抽象方法。
7.非抽象类继承抽象类的时候，必须要把抽象类中所以抽象方法全部实现。


abstract不能与以下关键字一起使用
    1.abstract不能与static共同修饰一个方法。
2.abstract不能与private共同修饰一个方法
3.abstract不能与final关键字共同修饰一个方法 






接口：


接口的定义格式：
    interface 接口名{
成员变量；
成员函数。。

}




接口的作用：




    1.程序的解耦
2.定义约束规范
3.拓展功能




接口要注意的细节：
    1.接口中成员变量都是常量，默认的修饰符public static final。
2.接口中的方法全部都是抽象方法，默认的修饰符： public abstract。
3.接口不能创建对象
4.接口没有构造函数的
5.非抽象类通过implements实现接口的时候，必须要把接口中所有方法全部实现。




接口与类之间的关系：实现关系


注意：一个类可以实现多个接口。


接口与接口之间的关系：继承关系


注意：一个接口可以继承多个接口的


多态：父类的引用类型变量指向了子类的对象，或者接口对的引用类型变量指向了接口实现类的对象




多态要注意的细节：
    1.多态情况下，如果子父类存在同名的成员变量时，访问的是父类的成员变量
2.多态情况下，如果子父类存在同名的非静态函数时，访问的是子类的成员函数。
3.多态情况下，如果子父类存在同名的静态函数时，访问的是父类的成员函数。
4.多态情况下，不能访问子类特有的成员


多态的应用：


    1.多态用于形参类型的时候，可以接收更多类型的数据。
2.多态用于返回值类型的时候，可以返回更多类型的数据
*/




class Demo1 
{
public static void main(String[] args) 
{
System.out.println("Hello World!");
}
}