五、Java面向对象：多态

合集 - JAVA学习笔记(22)

1.一、认识java以及环境变量2023-10-252.二、1、java基础之关键字、标识符、注释、常量、变量及数据类型2023-11-013.二、2、java基础之运算符与键盘录入（scanner）2023-11-014.二、3、java基础之流程控制语句2023-11-015.三、Java里的方法2023-11-016.四、Java之数组2023-11-017.五、Java面向对象概述2023-11-018.五、Java面向对象：封装2023-11-019.五、Java面向对象：继承2023-11-01

10.五、Java面向对象：多态2023-11-01

11.六、Java常用类：Object，Scanner2023-11-0112.六、Java常用类：String，StringBuffer2023-11-0813.六、Java常用类：Arrays,包装类,Random,System,Date,SimpleDateFormat2023-11-0814.七、Java集合2023-11-0815.八、Java集合其他知识2023-11-0816.九、IO流2023-11-0817.十、Java多线程和设计模式2023-11-0918.十一、网络编程2023-11-1019.十二、类加载器和反射2023-11-1020.Maven学习2023-11-1321.Git2023-11-1422.JDBC之Mysql2023-11-14

收起

一、多态介绍

概述：顾名思义就是事物在某种时刻的多种状态

前提；1、要有继承关系

　　　2、要有方法的重写

　　　3、要有父类的引用指向子类对象

 访问成员的特点：

　　　　　　　　访问成员变量：编译看左，运行看左

　　　　　　　　访问成员方法：编译看左，运行看右

　　　　　　　　访问静态成员方法：编译看左，运行看左

 多态的弊端：无法访问子类特有的成员方法（可以用向下转型来解决）

向下转型：

曹操和曹植的案例
class 曹操{
fight();

teach();
}

class 曹植 extends 曹操{
teach();

jump();
}
有一天，曹操出去打仗了，家里只有曹植在家，这时候敌人来了，将士们只听曹操的指挥
这时候曹植想到一个点子，开始装爹，穿上爹的衣服，粘上假胡子
曹操 c = new 曹植(); // 向上转型
c.teach();
曹操回来了，曹植做回自己，脱掉爹的衣服，撕掉假胡子
曹植 c2 = (曹植)c; // 向下转型
c2.teach();
c2.jump();

 二、abstract（抽象）

抽象类：不是具体的类
java针对描述现实生活中抽象的概念，提供了一个关键字给我们使用abstract

可以修饰类和成员方法

abstract使用的注意事项：
    1、修饰方法的时候，方法变成抽象方法，不能有具体的实现，连大括号都不能有
    2、当一个类中的方法是抽象方法的时候，这个类必须要定义成抽象类
    3、抽象类中既可以存在抽象方法，也可以存在具体的实现方法
    4、当一个具体的类继承抽象类的时候，必须要重写抽象父类中的所有抽象方法
    5、当抽象类继承抽象类的时候，可以不用重写抽象方法，也可以选择重写

package com.shujia.day07;


/*
    抽象类：不是具体的类
    java针对描述现实生活中抽象的概念，提供了一个关键字给我们使用abstract

    可以修饰类和方法

    abstract使用的注意事项：
        1、修饰方法的时候，方法变成抽象方法，不能有具体的实现，连大括号都不能有
        2、当一个类中的方法是抽象方法的时候，这个类必须要定义成抽象类
        3、抽象类中既可以存在抽象方法，也可以存在具体的实现方法
        4、当一个具体的类继承抽象类的时候，必须要重写抽象父类中的所有抽象方法
        5、当抽象类继承抽象类的时候，可以不用重写抽象方法，也可以选择重写
 */
abstract class Animal2{
    public abstract void eat();

    public abstract void sleep();

    public void fun1(){
        System.out.println("世界和平");
    }
}

abstract class Demo2 extends Animal2{
    @Override
    public void eat() {

    }
}

class Cat extends Animal2{

    @Override
    public void eat() {

    }

    @Override
    public void sleep() {

    }
}

class Dog2 extends Animal2{
    @Override
    public void eat(){
        System.out.println("🐕吃🥩");
    }

    @Override
    public void sleep(){
        System.out.println("🐕躺着睡");
    }
}

public class AbstractDemo1 {
    public static void main(String[] args) {
    }
}

 

抽象类中的成员特点：
    成员变量: 既可以是变量，也可以是常量
    构造方法: 抽象类无法被实例化，存在构造方法的意义是什么？用于做初始化的
    成员方法: 既可以是抽象方法，也可以是具体的实现

package com.shujia.day07;

/*
    抽象类中的成员特点：
        成员变量: 既可以是变量，也可以是常量
        构造方法: 抽象类无法被实例化，存在构造方法的意义是什么？用于做初始化的
        成员方法: 既可以是抽象方法，也可以是具体的实现
 */
abstract class Demo4{
    int a = 10;       // 变量
    final int b = 20; //常量
}

class Demo4Zi extends Demo4{
    public void fun1(){
        System.out.println(a);
        System.out.println(b);
    }
}

public class AbstractDemo3 {
    public static void main(String[] args) {
//        Demo4Zi dz = new Demo4Zi();
//        System.out.println(dz.a);
//        System.out.println(dz.b);

//        Demo4 d = new Demo4();
    }
}

 

 

一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义? 
可以
意义：  1. 提供模板或基类
　　　　2. 规范化子类结构
　　　　3. 防止直接实例化

abstract不能和哪些关键字共存
    1) 不能与private关键字共存
    2) 不能与static共存
    3) 不能与final共存

 

三、接口 interface

概述：用来描述类的额外扩展功能的，可以看作成一个特殊的类

功能：当一个类需要使用额外扩展功能的时候，使用implements关键字进行使用接口

接口中的成员特点：

　　　  成员变量：接口中只允许定义常量，默认存在修饰符 public static final

      构造方法：接口中不存在构造方法，无法进行实例化

    成员方法；接口中只允许定义抽象方法，方法默认会添加修饰符 public abstract

注意事项：
    1、类和接口的关系是实现关系，例如类Dog要实现Jump接口 class Dog implements Jump{}
    2、具体的类实现一个接口的时候，必须要实现接口中所有的抽象方法

package com.shujia.day07;
//将跳高定义成一个接口
interface Jump{
    int a = 10;
    void jumping();
}


abstract class Animal3{
    public abstract void eat();

    public abstract void sleep();
}

class Dog3 extends Animal3{

    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }

    @Override
    public void sleep() {
        System.out.println("狗趴着睡");
    }
}

//定义一个会跳高的狗
class JumpDog extends Dog3 implements Jump{

    @Override
    public void jumping() {
        System.out.println("狗会跳高");
    }
}

public class InterfaceDemo1 {
    public static void main(String[] args) {
//        Dog3 dog3 = new Dog3();
//        System.out.println(dog3.a);
//        System.out.println(Jump.a);

//        Jump j = new Jump();

        Jump j = new JumpDog();  //接口多态
        j.jumping();
//        j.eat();
//        j.sleep();
    }
}

 类与类,类与接口以及接口与接口类与类之间的关系：存在继承关系，只能单继承，不能多继承，但是可以多层继承，形成继承体系

类与接口的关系：存在实现关系，implements,可以一次性实现多个接口
接口与接口的关系：存在继承关系，可以存在多继承


四、包（文件夹，目录）
1、划分的方式
          根据功能划分
　　　　　　根据角色划分
2、导包的方式：
　　　　　　1、import xxx.xxxx.xxx;
　　　　　　2、在package和所有class之间进行导入
　　　　　　3、导入的时候可以使用.*的方式导入所有，但是不建议，因为将来会将项目打包

五、权限修饰符
1.Public（公共）: 当使用public修饰一个类、方法、变量或构造函数时，它们可以在任何地方被访问和使用，无论是在同一个包内还是在其他包中。

 2. Protected（受保护的）: 当使用protected修饰一个类成员时，它们可以在同一个包内和子类中被访问和使用。对于不同包中的非子类，只有在通过继承关系建立对象后才能访问。

3. Default（默认的，没有关键字修饰）: 如果没有使用任何修饰符来修饰一个类、方法、变量或构造函数，则它们具有默认访问级别。默认访问级别限定了只能在同一个包内进行访问和使用。

4. Private（私有的）: 当使用private修饰一个类成员时，它们只能在同一个类的内部被访问和使用，无法在其他类中进行访问。

 

六、内部类

 1、成员内部类：.

　　　　　　将类定义在类中方法外

　　　　　　常见的两种修饰符：static，private

2、局部内部类：

将类定义在成员方法的内部

 

3、匿名内部类

　　　　　　　　语句定义格式：new 类/抽象类/接口(){

　　　　　　　　　　　　　　　　　　　　 重写方法; }

　　　　　　　　主要使用场景：将匿名内部类作为方法的参数进行传递；将匿名内部类作为方法的返回值进行返回。

package com.shujia.day08.ketang;

/*
    匿名内部类的第二种用法：将匿名内部类作为返回值返回

 */

interface Inter2{
    void show();
}


//class Inter2Impl implements Inter2{
//    @Override
//    public void show() {
//        System.out.println("刘中义真帅！");
//    }
//}

class Inter2Demo{
    public Inter2 fun(){
//        return new Inter2Impl();
        //使用匿名内部类改写
        return new Inter2() {
            @Override
            public void show() {
                System.out.println("中义很帅！");
            }
        };
    }
}

public class NIMingInnerClassDemo2 {
    public static void main(String[] args) {
        Inter2Demo inter2Demo = new Inter2Demo();
        Inter2 inter2 = inter2Demo.fun();
        inter2.show();
    }
}