多态，强制类型转换，接口关系下的多态，成员内部类

面向对象的三大特征：
1. 封装　　
2. 继承　　
3. 多态

多态：一个对象具备多种形态。(父类的引用类型变量指向了子类的对象)

或者是接口 的引用类型变量指向了接口实现类的对象)

多态的前提：必须存在继承或者实现 关系。

动物 a = new 狗();

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

4. 多态情况下，不能访问子类特有的成员。

总结：多态情况下，子父类存在同名的成员时，访问的都是父类的成员，除了在同名非静态函数时才是访问子类的。

编译看左边，运行不一定看右边。

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

 代码 示例：

//动物类
abstract class Animal3{

    String name;

    String  color = "动物色";

    public Animal3(String name){
        this.name = name;
    }

    public abstract void run();

    public static void eat(){
        System.out.println("动物在吃..");
    }

}

//老鼠
class  Mouse1 extends Animal3{

    String color = "黑色";

    public Mouse1(String name){
        super(name);
    }

    public  void run(){
        System.out.println(name+"四条腿慢慢的走!");
    }

    public static void eat(){
        System.out.println("老鼠在偷吃..");
    }

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



class Fish1 extends Animal3 {

    public Fish1(String name){
        super(name);
    }


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


class Demo35
{
    public static void main(String[] args)
    {
      /*
      Mouse m = new Mouse("老鼠");
      System.out.println(m.color);

      //多态： 父类的引用类型变量指向子类的对象
      */
        Animal3 a = new Mouse1("老鼠");
        a.run();
        
    }
}
运行结果：

 

 

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

 

多态的好处： 提高了代码的拓展性。

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

代码 示例:

//图形类
abstract class MyShape1{

    public abstract void getArea();

    public abstract void getLength();
}



class Circle3 extends MyShape1{

    public static final double PI = 3.14;

    double r;

    public Circle3(double r){
        this.r =r ;
    }

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

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


class Rect1  extends MyShape1{

    int width;

    int height;

    public Rect1(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 Demo35 {

    public static void main(String[] args)
    {
      /*
      //System.out.println("Hello World!");
      Circle c = new Circle(4.0);
      print(c);

      Rect r = new Rect(3,4);
      print(r);
      */

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


    }


    //需求1： 定义一个函数可以接收任意类型的图形对象，并且打印图形面积与周长。
    public static void print(MyShape s){ // MyShpe s = new Circle(4.0);
        s.getArea();
        s.getLength();
    }


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

}
运行结果：

 

 

抽象类：

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

抽象类要注意的细节：
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 fianl.
2. 接口中的方法全部都是抽象的方法，默认的修饰符： public abstract。
3. 接口不能创建对象。
4. 接口是没有构造函数 的。
5. 非抽象类通过implements实现接口的时候，必须要把接口中所有方法全部实现。


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

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

接口与接口之间的关系： 继续关系。

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


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


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

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


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

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


基本数据类型的转换

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

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


引用数据类型的转换

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

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

类型转换最场景的问题： java.lang.ClassCastException。 强制类型转换失败。

代码示例：

//动物类
abstract class Animal3{

    String name;

    public Animal3(String name){
        this.name = name;
    }

    public abstract void run();
}

//老鼠
class  Mouse1 extends Animal3{


    public Mouse1(String name){
        super(name);
    }

    public  void run(){
        System.out.println(name+"四条腿慢慢的走!");
    }

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



//鱼
class Fish2 extends Animal3{

    public Fish2(String name){
        super(name);
    }

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


    //吹泡泡
    public void bubble(){
        System.out.println(name+"吹泡泡...!");
    }

}




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

        Mouse1 m = new Mouse1("米老鼠");
        Fish2 f = new Fish2("草鱼");

        print(f);

    }


    //需求： 定义一个函数可以接收任意类型的动物对象，在函数内部要调用到动物特有的方法。
    public static void print(Animal3 a){ // Animal a   = new Mouse("米老鼠");
        if(a instanceof Fish2){
            Fish2 f = (Fish2)a;
            f.bubble();
        }else if(a instanceof Mouse1){
            Mouse1 m = (Mouse1)a;
            m.dig();
        }
    }

}
运行代码:

 

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

实现关系下的多态：

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

代码演示：

interface Dao{  //接口的方法全部都是非静态的方法。

    public void add();

    public void delete();
}



//接口的实现类
class UserDao implements Dao{

    public void add(){
        System.out.println("添加员工成功！！");
    }

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

}

class Demo1
{
    public static void main(String[] args)
    {
        //实现关系下的多态
        Dao d = new UserDao(); //接口的引用类型变量指向了接口实现类的对象。
        d.delete();


    }
}
运行结果：

 

内部类：一个类定义在另外一个类的内部，那么该类就称作为内部类。

内部类的class文件名： 外部类$内部类. 好处：便于区分该class文件是属于哪个外部类的。

内部类的类别：

1. 成员内部类:

成员内部类的访问方式：

　　方式一：在外部类提供一个方法创建内部类的对象进行访问。

　　方式2二：在其他类直接创建内部类的对象。 格式：外部类.内部类 变量名 = new 外部类().new 内部类();

注意： 如果是一个静态内部类，那么在其他类创建 的格式：
　　　　　　　　外部类.内部类 变量名 = new 外部类.内部类();


内部类的应用场景： 我们在描述A事物的时候，发现描述的A事物内部还存在另外一个比较
复杂的事物B时候，而且这个比较复杂事物B还需要访问A事物的属性等数据，那么这时候
我们就可以使用内部类描述B事物。

比如： 人--->心脏

class 人{

血

氧气

等....

class 心脏{

}

}

内部类的好处：内部类可以直接访问外部类的所有成员。

 

内部类要注意的细节：
1. 如果外部类与内部类存在同名的成员变量时，在内部类中默认情况下是访问内部类的成员变量。
可以通过"外部类.this.成员变量名" 指定访问外部类的 成员。
2. 私有的成员内部类只能在外部类提供一个方法创建内部类的对象进行访问，不能在其他类创建对象了。
3. 成员内部类一旦出现了静态的成员，那么该类也必须 使用static修饰。

代码演示：

//外部类
class Outer{

    //成员变量
    int x = 100; // Outer.class文件被加载到内存的时候存在内存中。  静态的成员数据是不需要对象存在才能访问。

    //成员内部类
    static class Inner{

        static int i = 10;

        public void print(){
            System.out.println("这个是成员内部类的print方法！"+i);
        }
    }

    //在外部的方法中创建了内部类的对象，然后调用内部 方法。
    public void instance(){
        Inner inner = new Inner();
        inner.print();
    }

}

//其他类
class Demo2
{
    public static void main(String[] args)
    {
      /*
      System.out.println(Outer.Inner.i);

      Outer outer = new Outer();
      outer.instance();


      Outer.Inner inner = new Outer().new Inner();
      inner.print();
      */

       Outer.Inner inner = new Outer.Inner();
        inner.print();
    }
}
运行结果：

 

posted @   柯基$  阅读(74)  评论(0)  编辑  收藏  举报
相关博文：
·  复习，final关键字,抽象类，抽象类的练习以及不能与指定关键字一起使用
·  复习，静态函数，main方法的详解，单例设计模式
·  多态、内部类
·  day18_面向对象的三大特征之多态
·  Day03多态——常用API
阅读排行：
· 使用C#创建一个MCP客户端
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· ollama系列1：轻松3步本地部署deepseek，普通电脑可用
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· 按钮权限的设计及实现
点击右上角即可分享
微信分享提示
AI IDE Trae