继承和内部类和接口

最新推荐文章于 2024-06-08 16:24:59 发布
最新推荐文章于 2024-06-08 16:24:59 发布
阅读量262 收藏 1
点赞数
分类专栏： Java基础 文章标签： java 数据库 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wangzc_1116/article/details/130772441
版权

1. 继承

1.1 继承的实现（掌握）

  • 继承的概念

    • 继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法

  • 实现继承的格式

    • 继承通过extends实现

    • 格式：class 子类 extends 父类 { }

      • 举例：class Dog extends Animal { }

  • 继承带来的好处

    • 继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员。

  • 示例代码

    public class Fu {
    public void show() {
        System.out.println("show方法被调用");
    }
}
public class Zi extends Fu {
    public void method() {
        System.out.println("method方法被调用");
    }
}
public class Demo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Fu f = new Fu();
        f.show();
​
        Zi z = new Zi();
        z.method();
        z.show();
    }
}

1.2 继承的好处和弊端（理解）

  • 继承好处

    • 提高了代码的复用性(多个类相同的成员可以放到同一个类中)

    • 提高了代码的维护性(如果方法的代码需要修改，修改一处即可)

  • 继承弊端

    • 继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性

  • 继承的应用场景：

    • 使用继承，需要考虑类与类之间是否存在is..a的关系，不能盲目使用继承

      • is..a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类

1.3. Java中继承的特点（掌握）

  • Java中继承的特点

    1. Java中类只支持单继承，不支持多继承

      • 错误范例：class A extends B, C { }

    2. Java中类支持多层继承

  • 多层继承示例代码：

    public class Granddad {
​
    public void drink() {
        System.out.println("爷爷爱喝酒");
    }
​
}
​
public class Father extends Granddad {
​
    public void smoke() {
        System.out.println("爸爸爱抽烟");
    }
​
}
​
public class Mother {
​
    public void dance() {
        System.out.println("妈妈爱跳舞");
    }
​
}
public class Son extends Father {
    // 此时，Son类中就同时拥有drink方法以及smoke方法
}

2. 继承中的成员访问特点

2.1 继承中变量的访问特点（掌握）

在子类方法中访问一个变量，采用的是就近原则。

  1. 子类局部范围找

  2. 子类成员范围找

  3. 父类成员范围找

  4. 如果都没有就报错(不考虑父亲的父亲…)

  • 示例代码

    class Fu {
    int num = 10;
}
class Zi {
    int num = 20;
    public void show(){
        int num = 30;
        System.out.println(num);
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();   // 输出show方法中的局部变量30
    }
}

2.2 super（掌握）

  • this&super关键字：

    • this：代表本类对象的引用

    • super：代表父类存储空间的标识(可以理解为父类对象引用)

  • this和super的使用分别

    • 成员变量：

      • this.成员变量 - 访问本类成员变量

      • super.成员变量 - 访问父类成员变量

    • 成员方法：

      • this.成员方法 - 访问本类成员方法

      • super.成员方法 - 访问父类成员方法

  • 构造方法：

    • this(…) - 访问本类构造方法

    • super(…) - 访问父类构造方法

2.3 继承中构造方法的访问特点（理解）

注意：子类中所有的构造方法默认都会访问父类中无参的构造方法

子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，原因在于，每一个子类构造方法的第一条语句默认都是：super()

问题：如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？

1. 通过使用super关键字去显示的调用父类的带参构造方法
2. 子类通过this去调用本类的其他构造方法,本类其他构造方法再通过super去手动调用父类的带参的构造方法
​
注意: this(…)super(…) 必须放在构造方法的第一行有效语句，并且二者不能共存

2.4 继承中成员方法的访问特点（掌握）

通过子类对象访问一个方法

  1. 子类成员范围找

  2. 父类成员范围找

  3. 如果都没有就报错(不考虑父亲的父亲…)

2.5 super内存图（理解）

  • 对象在堆内存中，会单独存在一块super区域，用来存放父类的数据

     

2.6 方法重写（掌握）

  • 1、方法重写概念

    • 子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）

  • 2、方法重写的应用场景

    • 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

  • 3、Override注解

    • 用来检测当前的方法，是否是重写的方法，起到【校验】的作用

2.7 方法重写的注意事项（掌握）

  • 方法重写的注意事项

  1. 私有方法不能被重写(父类私有成员子类是不能继承的)

  2. 子类方法访问权限不能更低(public > 默认 > 私有)

  3. 静态方法不能被重写,如果子类也有相同的方法,并不是重写的父类的方法

  • 示例代码

public class Fu {
    private void show() {
        System.out.println("Fu中show()方法被调用");
    }
​
    void method() {
        System.out.println("Fu中method()方法被调用");
    }
}
​
public class Zi extends Fu {
​
    /* 编译【出错】，子类不能重写父类私有的方法*/
    @Override
    private void show() {
        System.out.println("Zi中show()方法被调用");
    }
   
    /* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    private void method() {
        System.out.println("Zi中method()方法被调用");
    }
​
    /* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    public void method() {
        System.out.println("Zi中method()方法被调用");
    }
}

2.8 权限修饰符 (理解)

2.9 黑马信息管理系统使用继承改进 (掌握)

 

  • 需求

    把学生类和老师类共性的内容向上抽取,抽取到出一个 Person 父类,让学生类和老师类继承 Person 类

  • 实现步骤

    1. 抽取Person类

    2. 优化StudentController类中，inputStudentInfo方法，将setXxx赋值方式，改进为构造方法初始化

      注意：直接修改这种操作方式，不符合我们开发中的一个原则

      开闭原则 ( 对扩展开放对修改关闭 ) : 尽量在不更改原有代码的前提下以完成需求

      解决：重新创建一个OtherStudentController类

      编写新的inputStudentInfo方法

    3. 根据StudentController类、OtherStudentController类，向上抽取出BaseStudentController类 再让StudentController类、OtherStudentController类，继承BaseStudentController类

  • 代码实现

    Person类及学生类和老师类

    public class Person {
    private String id;
    private String name;
    private String age;
    private String birthday;
​
    public Person() {
    }
​
    public Person(String id, String name, String age, String birthday) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }
​
    public String getId() {
        return id;
    }
​
    public void setId(String id) {
        this.id = id;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public String getAge() {
        return age;
    }
​
    public void setAge(String age) {
        this.age = age;
    }
​
    public String getBirthday() {
        return birthday;
    }
​
    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }
}
// Student类
public class Student extends Person {
    public Student() {
    }
​
    public Student(String id, String name, String age, String birthday) {
        super(id, name, age, birthday);
    }
}
// Teacher类
public class Teacher extends Person {
    public Teacher() {
    }
​
    public Teacher(String id, String name, String age, String birthday) {
        super(id, name, age, birthday);
    }
}

    BaseStudentController类

    public abstract class BaseStudentController {
    // 业务员对象
    private StudentService studentService = new StudentService();
​
    private Scanner sc = new Scanner(System.in);
​
    // 开启学生管理系统, 并展示学生管理系统菜单
    public void start() {
        //Scanner sc = new Scanner(System.in);
        studentLoop:
        while (true) {
            System.out.println("--------欢迎来到 <学生> 管理系统--------");
            System.out.println("请输入您的选择: 1.添加学生  2.删除学生  3.修改学生  4.查看学生  5.退出");
            String choice = sc.next();
            switch (choice) {
                case "1":
                    // System.out.println("添加");
                    addStudent();
                    break;
                case "2":
                    // System.out.println("删除");
                    deleteStudentById();
                    break;
                case "3":
                    // System.out.println("修改");
                    updateStudent();
                    break;
                case "4":
                    // System.out.println("查询");
                    findAllStudent();
                    break;
                case "5":
                    System.out.println("感谢您使用学生管理系统, 再见!");
                    break studentLoop;
                default:
                    System.out.println("您的输入有误, 请重新输入");
                    break;
            }
        }
    }
​
    // 修改学生方法
    public void updateStudent() {
        String updateId = inputStudentId();
        Student newStu = inputStudentInfo(updateId);
        studentService.updateStudent(updateId, newStu);
​
        System.out.println("修改成功!");
    }
​
    // 删除学生方法
    public void deleteStudentById() {
        String delId = inputStudentId();
        // 3. 调用业务员中的deleteStudentById根据id, 删除学生
        studentService.deleteStudentById(delId);
        // 4. 提示删除成功
        System.out.println("删除成功!");
    }
​
    // 查看学生方法
    public void findAllStudent() {
        // 1. 调用业务员中的获取方法, 得到学生的对象数组
        Student[] stus = studentService.findAllStudent();
        // 2. 判断数组的内存地址, 是否为null
        if (stus == null) {
            System.out.println("查无信息, 请添加后重试");
            return;
        }
        // 3. 遍历数组, 获取学生信息并打印在控制台
        System.out.println("学号\t\t姓名\t年龄\t生日");
        for (int i = 0; i < stus.length; i++) {
            Student stu = stus[i];
            if (stu != null) {
                System.out.println(stu.getId() + "\t" + stu.getName() + "\t" + stu.getAge() + "\t\t" + stu.getBirthday());
            }
        }
    }
​
    // 添加学生方法
    public void addStudent() {
        // StudentService studentService = new StudentService();
        // 1. 键盘接收学生信息
        String id;
        while (true) {
            System.out.println("请输入学生id:");
            id = sc.next();
            boolean flag = studentService.isExists(id);
            if (flag) {
                System.out.println("学号已被占用, 请重新输入");
            } else {
                break;
            }
        }
​
        Student stu = inputStudentInfo(id);
​
        // 3. 将学生对象,传递给StudentService(业务员)中的addStudent方法
        boolean result = studentService.addStudent(stu);
        // 4. 根据返回的boolean类型结果, 在控制台打印成功\失败
        if (result) {
            System.out.println("添加成功");
        } else {
            System.out.println("添加失败");
        }
    }
​
    // 键盘录入学生id
    public String inputStudentId() {
        String id;
        while (true) {
            System.out.println("请输入学生id:");
            id = sc.next();
            boolean exists = studentService.isExists(id);
            if (!exists) {
                System.out.println("您输入的id不存在, 请重新输入:");
            } else {
                break;
            }
        }
        return id;
    }
​
    // 键盘录入学生信息
    // 开闭原则: 对扩展内容开放, 对修改内容关闭
  public Student inputStudentInfo(String id){
    return null;
  }
}

    StudentController类

    public class StudentController extends BaseStudentController {
​
    private Scanner sc = new Scanner(System.in);
​
    // 键盘录入学生信息
    // 开闭原则: 对扩展内容开放, 对修改内容关闭
    @Override
    public Student inputStudentInfo(String id) {
        System.out.println("请输入学生姓名:");
        String name = sc.next();
        System.out.println("请输入学生年龄:");
        String age = sc.next();
        System.out.println("请输入学生生日:");
        String birthday = sc.next();
        Student stu = new Student();
        stu.setId(id);
        stu.setName(name);
        stu.setAge(age);
        stu.setBirthday(birthday);
        return stu;
    }
}

    OtherStudentController类

    public class OtherStudentController extends BaseStudentController {

    private Scanner sc = new Scanner(System.in);

    // 键盘录入学生信息
    // 开闭原则: 对扩展内容开放, 对修改内容关闭
    @Override
    public Student inputStudentInfo(String id) {
        System.out.println("请输入学生姓名:");
        String name = sc.next();
        System.out.println("请输入学生年龄:");
        String age = sc.next();
        System.out.println("请输入学生生日:");
        String birthday = sc.next();
        Student stu = new Student(id,name,age,birthday);
        return stu;
    }
}

3.抽象类

3.1抽象类的概述（理解）

当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！

在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类！

3.2抽象类的特点（记忆）

  • 抽象类和抽象方法必须使用 abstract 关键字修饰

    //抽象类的定义
public abstract class 类名 {}

//抽象方法的定义
public abstract void eat();

  • 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

  • 抽象类不能实例化

  • 抽象类可以有构造方法

  • 抽象类的子类

    要么重写抽象类中的所有抽象方法

    要么是抽象类

3.3抽象类的案例（应用）

  • 案例需求

    定义猫类(Cat)和狗类(Dog)

    猫类成员方法：eat（猫吃鱼）drink（喝水…）

    狗类成员方法：eat（狗吃肉）drink（喝水…）

  • 实现步骤

    1. 猫类和狗类中存在共性内容，应向上抽取出一个动物类（Animal）

    2. 父类Animal中，无法将 eat 方法具体实现描述清楚，所以定义为抽象方法

    3. 抽象方法需要存活在抽象类中，将Animal定义为抽象类

    4. 让 Cat 和 Dog 分别继承 Animal，重写eat方法

    5. 测试类中创建 Cat 和 Dog 对象，调用方法测试

  • 代码实现

    • 动物类

    public abstract class Animal {
    public void drink(){
        System.out.println("喝水");
    }

    public Animal(){

    }

    public abstract void eat();
}

    • 猫类

    public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

    • 狗类

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

    • 测试类

    public static void main(String[] args) {
        Dog d = new Dog();
        d.eat();
        d.drink();

        Cat c = new Cat();
        c.drink();
        c.eat();

        //Animal a = new Animal();
        //a.eat();
    }

3.4模板设计模式

  • 设计模式

    设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。 使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。

  • 模板设计模式

    把抽象类整体就可以看做成一个模板，模板中不能决定的东西定义成抽象方法 让使用模板的类（继承抽象类的类）去重写抽象方法实现需求

  • 模板设计模式的优势

    模板已经定义了通用结构，使用者只需要关心自己需要实现的功能即可

  • 示例代码

    模板类

    /*
    作文模板类
 */
public abstract class CompositionTemplate {

    public final void write(){
        System.out.println("<<我的爸爸>>");

        body();

        System.out.println("啊~ 这就是我的爸爸");

    }

    public abstract void body();
}

    实现类A

    public class Tom extends CompositionTemplate {

    @Override
    public void body() {
        System.out.println("那是一个秋天, 风儿那么缠绵,记忆中, " +
                "那天爸爸骑车接我放学回家,我的脚卡在了自行车链当中, 爸爸蹬不动,他就站起来蹬...");
    }
}

    实现类B

    public class Tony extends CompositionTemplate {
    @Override
    public void body() {

    }

    /*public void write(){

    }*/
}

    测试类

    public class Test {
    public static void main(String[] args) {
        Tom t = new Tom();
        t.write();
    }
}

3.5final（应用）

  • fianl关键字的作用

    • final代表最终的意思，可以修饰成员方法，成员变量，类

  • final修饰类、方法、变量的效果

    • fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）

    • final修饰方法：该方法不能被重写

    • final修饰变量：表明该变量是一个常量，不能再次赋值

      • 变量是基本类型,不能改变的是值

      • 变量是引用类型,不能改变的是地址值,但地址里面的内容是可以改变的

      • 举例

        public static void main(String[] args){
    final Student s = new Student(23);
  	s = new Student(24);  // 错误
 	s.setAge(24);  // 正确
}

3.6黑马信息管理系统使用抽象类改进 (应用)

  • 需求

    1. 使用抽象类的思想，将BaseStudentController 中的 inputStudentInfo 方法，定义为抽象方法

    2. 将不希望子类重写的方法，使用 final 进行修饰

  • 代码实现

    BaseStudentController类

    public abstract class BaseStudentController {
    // 业务员对象
    private StudentService studentService = new StudentService();

    private Scanner sc = new Scanner(System.in);

    // 开启学生管理系统, 并展示学生管理系统菜单
    public final void start() {
        //Scanner sc = new Scanner(System.in);
        studentLoop:
        while (true) {
            System.out.println("--------欢迎来到 <学生> 管理系统--------");
            System.out.println("请输入您的选择: 1.添加学生  2.删除学生  3.修改学生  4.查看学生  5.退出");
            String choice = sc.next();
            switch (choice) {
                case "1":
                    // System.out.println("添加");
                    addStudent();
                    break;
                case "2":
                    // System.out.println("删除");
                    deleteStudentById();
                    break;
                case "3":
                    // System.out.println("修改");
                    updateStudent();
                    break;
                case "4":
                    // System.out.println("查询");
                    findAllStudent();
                    break;
                case "5":
                    System.out.println("感谢您使用学生管理系统, 再见!");
                    break studentLoop;
                default:
                    System.out.println("您的输入有误, 请重新输入");
                    break;
            }
        }
    }

    // 修改学生方法
    public final void updateStudent() {
        String updateId = inputStudentId();
        Student newStu = inputStudentInfo(updateId);
        studentService.updateStudent(updateId, newStu);

        System.out.println("修改成功!");
    }

    // 删除学生方法
    public final void deleteStudentById() {
        String delId = inputStudentId();
        // 3. 调用业务员中的deleteStudentById根据id, 删除学生
        studentService.deleteStudentById(delId);
        // 4. 提示删除成功
        System.out.println("删除成功!");
    }

    // 查看学生方法
    public final void findAllStudent() {
        // 1. 调用业务员中的获取方法, 得到学生的对象数组
        Student[] stus = studentService.findAllStudent();
        // 2. 判断数组的内存地址, 是否为null
        if (stus == null) {
            System.out.println("查无信息, 请添加后重试");
            return;
        }
        // 3. 遍历数组, 获取学生信息并打印在控制台
        System.out.println("学号\t\t姓名\t年龄\t生日");
        for (int i = 0; i < stus.length; i++) {
            Student stu = stus[i];
            if (stu != null) {
                System.out.println(stu.getId() + "\t" + stu.getName() + "\t" + stu.getAge() + "\t\t" + stu.getBirthday());
            }
        }
    }

    // 添加学生方法
    public final void addStudent() {
        // StudentService studentService = new StudentService();
        // 1. 键盘接收学生信息
        String id;
        while (true) {
            System.out.println("请输入学生id:");
            id = sc.next();
            boolean flag = studentService.isExists(id);
            if (flag) {
                System.out.println("学号已被占用, 请重新输入");
            } else {
                break;
            }
        }

        Student stu = inputStudentInfo(id);

        // 3. 将学生对象,传递给StudentService(业务员)中的addStudent方法
        boolean result = studentService.addStudent(stu);
        // 4. 根据返回的boolean类型结果, 在控制台打印成功\失败
        if (result) {
            System.out.println("添加成功");
        } else {
            System.out.println("添加失败");
        }
    }

    // 键盘录入学生id
    public String inputStudentId() {
        String id;
        while (true) {
            System.out.println("请输入学生id:");
            id = sc.next();
            boolean exists = studentService.isExists(id);
            if (!exists) {
                System.out.println("您输入的id不存在, 请重新输入:");
            } else {
                break;
            }
        }
        return id;
    }

    // 键盘录入学生信息
    // 开闭原则: 对扩展内容开放, 对修改内容关闭
  public abstract Student inputStudentInfo(String id);
}

4.代码块

4.1代码块概述 (理解)

在Java中，使用 { } 括起来的代码被称为代码块

4.2代码块分类 (理解)

  • 局部代码块

    • 位置: 方法中定义

    • 作用: 限定变量的生命周期，及早释放，提高内存利用率

    • 示例代码

      public class Test {
    /*
        局部代码块
            位置：方法中定义
            作用：限定变量的生命周期，及早释放，提高内存利用率
     */
    public static void main(String[] args) {
        {
            int a = 10;
            System.out.println(a);
        }

       // System.out.println(a);
    }
}

  • 构造代码块

    • 位置: 类中方法外定义

    • 特点: 每次构造方法执行的时，都会执行该代码块中的代码，并且在构造方法执行前执行

    • 作用: 将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性

    • 示例代码

      public class Test {
    /*
        构造代码块:
            位置：类中方法外定义
            特点：每次构造方法执行的时，都会执行该代码块中的代码，并且在构造方法执行前执行
            作用：将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性
     */
    public static void main(String[] args) {
        Student stu1 = new Student();
        Student stu2 = new Student(10);
    }
}

class Student {

    {
        System.out.println("好好学习");
    }

    public Student(){
        System.out.println("空参数构造方法");
    }

    public Student(int a){
        System.out.println("带参数构造方法...........");
    }
}

  • 静态代码块

    • 位置: 类中方法外定义

    • 特点: 需要通过static关键字修饰，随着类的加载而加载，并且只执行一次

    • 作用: 在类加载的时候做一些数据初始化的操作

    • 示例代码

      public class Test {
    /*
        静态代码块:
            位置：类中方法外定义
            特点：需要通过static关键字修饰，随着类的加载而加载，并且只执行一次
            作用：在类加载的时候做一些数据初始化的操作
     */
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person(10);
    }
}

class Person {
    static {
        System.out.println("我是静态代码块, 我执行了");
    }

    public Person(){
        System.out.println("我是Person类的空参数构造方法");
    }

    public Person(int a){
        System.out.println("我是Person类的带...........参数构造方法");
    }
}

4.3黑马信息管理系统使用代码块改进 (应用)

1.2黑马信息管理系统抽取Dao (应用)

1.3接口的概述（理解）

1.4接口的特点（记忆）

1.5接口的成员特点（记忆）

1.6类和接口的关系（记忆）

1.7黑马信息管理系统使用接口改进 (应用)

1.8黑马信息管理系统解耦合改进 (应用)

2.接口组成更新

2.1接口组成更新概述【理解】

2.2接口中默认方法【应用】

2.3接口中静态方法【应用】

2.4接口中私有方法【应用】

3.多态

3.1多态的概述（记忆）

3.2多态中的成员访问特点（记忆）

3.3多态的好处和弊端（记忆）

3.4多态中的转型（应用）

3.5多态中转型存在的风险和解决方案 (应用)

3.6黑马信息管理系统多态改进 (应用)

4.内部类

4.1 内部类的基本使用（理解）

2.2 成员内部类（理解）

2.3 局部内部类（理解）

2.4 匿名内部类（应用）

2.4 匿名内部类在开发中的使用（应用）

5.Lambda表达式

5.1体验Lambda表达式【理解】

5.2Lambda表达式的标准格式【理解】

5.3Lambda表达式练习1【应用】

5.4Lambda表达式练习2【应用】

5.5Lambda表达式练习3【应用】

5.6Lambda表达式的省略模式【应用】

5.7Lambda表达式的使用前提【理解】

5.8Lambda表达式和匿名内部类的区别【理解】

  • 需求

    使用静态代码块，初始化一些学生数据

  • 实现步骤

    1. 在StudentDao类中定义一个静态代码块，用来初始化一些学生数据

    2. 将初始化好的学生数据存储到学生数组中

  • 示例代码

    StudentDao类

    public class StudentDao {
    // 创建学生对象数组
    private static Student[] stus = new Student[5];

    static {
        Student stu1 = new Student("heima001","张三","23","1999-11-11");
        Student stu2 = new Student("heima002","李四","24","2000-11-11");

        stus[0] = stu1;
        stus[1] = stu2;
    }

    // 添加学生方法
    public boolean addStudent(Student stu) {

        // 2. 添加学生到数组
        //2.1 定义变量index为-1，假设数组已经全部存满，没有null的元素
        int index = -1;
        //2.2 遍历数组取出每一个元素，判断是否是null
        for (int i = 0; i < stus.length; i++) {
            Student student = stus[i];
            if(student == null){
                index = i;
                //2.3 如果为null，让index变量记录当前索引位置，并使用break结束循环遍历
                break;
            }
        }

        // 3. 返回是否添加成功的boolean类型状态
        if(index == -1){
            // 装满了
            return false;
        }else{
            // 没有装满, 正常添加, 返回true
            stus[index] = stu;
            return true;
        }
    }
    // 查看学生方法
    public Student[] findAllStudent() {
        return stus;
    }

    public void deleteStudentById(String delId) {
        // 1. 查找id在容器中所在的索引位置
        int index = getIndex(delId);
        // 2. 将该索引位置,使用null元素进行覆盖
        stus[index] = null;
    }

    public int getIndex(String id){
        int index = -1;
        for (int i = 0; i < stus.length; i++) {
            Student stu = stus[i];
            if(stu != null && stu.getId().equals(id)){
                index = i;
                break;
            }
        }
        return index;
    }

    public void updateStudent(String updateId, Student newStu) {
        // 1. 查找updateId, 在容器中的索引位置
        int index = getIndex(updateId);
        // 2. 将该索引位置, 使用新的学生对象替换
        stus[index] = newStu;
    }
}

    1.接口

    1.1黑马信息管理系统集合改进 (应用)

  • 使用数组容器的弊端

    1. 容器长度是固定的，不能根据添加功能自动增长

    2. 没有提供用于赠删改查的方法

  • 优化步骤

    1. 创建新的StudentDao类，OtherStudentDao

    2. 创建ArrayList集合容器对象

    3. OtherStudentDao中的方法声明，需要跟StudentDao保持一致

      注意：如果不一致，StudentService中的代码就需要进行修改

    4. 完善方法（添加、删除、修改、查看）

    5. 替换StudentService中的Dao对象

  • 代码实现

    OtherStudentDao类

    public class OtherStudentDao {
    // 集合容器
    private static ArrayList<Student> stus = new ArrayList<>();
​
    static {
        Student stu1 = new Student("heima001","张三","23","1999-11-11");
        Student stu2 = new Student("heima002","李四","24","2000-11-11");
​
        stus.add(stu1);
        stus.add(stu2);
    }
​
    // 添加学生方法
    public boolean addStudent(Student stu) {
       stus.add(stu);
       return true;
    }
​
    // 查看学生方法
    public Student[] findAllStudent() {
​
        Student[] students = new Student[stus.size()];
​
        for (int i = 0; i < students.length; i++) {
            students[i] = stus.get(i);
        }
​
        return students;
    }
​
    public void deleteStudentById(String delId) {
        // 1. 查找id在容器中所在的索引位置
        int index = getIndex(delId);
        stus.remove(index);
    }
​
    public int getIndex(String id){
        int index = -1;
        for (int i = 0; i < stus.size(); i++) {
            Student stu = stus.get(i);
            if(stu != null && stu.getId().equals(id)){
                index = i;
                break;
            }
        }
        return index;
    }
​
    public void updateStudent(String updateId, Student newStu) {
        // 1. 查找updateId, 在容器中的索引位置
        int index = getIndex(updateId);
        stus.set(index, newStu);
    }
}

    StudentService类

    public class StudentService {
    // 创建StudentDao (库管)
     private OtherStudentDao studentDao = new OtherStudentDao();
    // 其他方法没有变化,此处省略...
}    

  • 优化步骤

    1. 将方法向上抽取，抽取出一个父类 （ BaseStudentDao ）

    2. 方法的功能实现在父类中无法给出具体明确，定义为抽象方法

    3. 让两个类分别继承 BaseStudentDao ，重写内部抽象方法

  • 代码实现

    BaseStudentDao类

    public abstract class BaseStudentDao {
    // 添加学生方法
    public abstract boolean addStudent(Student stu);
    // 查看学生方法
    public abstract Student[] findAllStudent();
    // 删除学生方法
    public abstract void deleteStudentById(String delId);
    // 根据id找索引方法
    public abstract int getIndex(String id);
    // 修改学生方法
    public abstract void updateStudent(String updateId, Student newStu);
}

    StudentDao类

    public class StudentDao extends BaseStudentDao {
  // 其他内容不变,此处省略
}

    OtherStudentDao类

    public class OtherStudentDao extends BaseStudentDao {
  // 其他内容不变,此处省略
}

  • 接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。

  • Java中接口存在的两个意义

    1. 用来定义规范

    2. 用来做功能的拓展

  • 接口用关键字interface修饰

    public interface 接口名 {}

  • 类实现接口用implements表示

    public class 类名 implements 接口名 {}

  • 接口不能实例化

    我们可以创建接口的实现类对象使用

  • 接口的子类

    要么重写接口中的所有抽象方法

    要么子类也是抽象类

  • 成员特点

    • 成员变量

      只能是常量 ​ 默认修饰符：public static final

    • 构造方法

      没有，因为接口主要是扩展功能的，而没有具体存在

    • 成员方法

      只能是抽象方法

      默认修饰符：public abstract

      关于接口中的方法，JDK8和JDK9中有一些新特性，后面再讲解

  • 代码演示

    • 接口

    public interface Inter {
    public static final int NUM = 10;
​
    public abstract void show();
}

    • 实现类

    class InterImpl implements Inter{

    public void method(){
        // NUM = 20;
        System.out.println(NUM);
    }

    public void show(){

    }
}

    • 测试类

    public class TestInterface {
    /*
        成员变量: 只能是常量 系统会默认加入三个关键字
                    public static final
        构造方法: 没有
        成员方法: 只能是抽象方法, 系统会默认加入两个关键字
                    public abstract
     */
    public static void main(String[] args) {
        System.out.println(Inter.NUM);
    }
  
}

  • 类与类的关系

    继承关系，只能单继承，但是可以多层继承

  • 类与接口的关系

    实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

  • 接口与接口的关系

    继承关系，可以单继承，也可以多继承

  • 实现步骤

    1. 将 BaseStudentDao 改进为一个接口

    2. 让 StudentDao 和 OtherStudentDao 去实现这个接口

  • 代码实现

    BaseStudentDao接口

    public interface BaseStudentDao {
    // 添加学生方法
    public abstract boolean addStudent(Student stu);
    // 查看学生方法
    public abstract Student[] findAllStudent();
    // 删除学生方法
    public abstract void deleteStudentById(String delId);
    // 根据id找索引方法
    public abstract int getIndex(String id);
    // 修改学生方法
    public abstract void updateStudent(String updateId, Student newStu);
}

    StudentDao类

    public class StudentDao implements BaseStudentDao {
  // 其他内容不变,此处省略
}

    OtherStudentDao类

    public class OtherStudentDao implements BaseStudentDao {
  // 其他内容不变,此处省略
}

  • 实现步骤

    1. 创建factory包，创建 StudentDaoFactory（工厂类）

    2. 提供 static 修改的 getStudentDao 方法，该方法用于创建StudentDao对象并返回

  • 代码实现

    StudentDaoFactory类

    public class StudentDaoFactory {
    public static OtherStudentDao getStudentDao(){
        return new OtherStudentDao();
    }
}

    StudentService类

    public class StudentService {
    // 创建StudentDao (库管)
    // private OtherStudentDao studentDao = new OtherStudentDao();

    // 通过学生库管工厂类, 获取库管对象
    private OtherStudentDao studentDao = StudentDaoFactory.getStudentDao();
}

  • 常量

    public static final

  • 抽象方法

    public abstract

  • 默认方法(Java 8)

  • 静态方法(Java 8)

  • 私有方法(Java 9)

  • 格式

    public default 返回值类型 方法名(参数列表) { }

  • 作用

    解决接口升级的问题

  • 范例

    public default void show3() { 
}

  • 注意事项

    • 默认方法不是抽象方法，所以不强制被重写。但是可以被重写，重写的时候去掉default关键字

    • public可以省略，default不能省略

    • 如果实现了多个接口，多个接口中存在相同的方法声明，子类就必须对该方法进行重写

  • 格式

    public static 返回值类型 方法名(参数列表) { }

  • 范例

    public static void show() {
}

  • 注意事项

    • 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用

    • public可以省略，static不能省略

  • 私有方法产生原因

    Java 9中新增了带方法体的私有方法，这其实在Java 8中就埋下了伏笔：Java 8允许在接口中定义带方法体的默认方法和静态方法。这样可能就会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段实现代码抽取成一个共性方法，而这个共性方法是不需要让别人使用的，因此用私有给隐藏起来，这就是Java 9增加私有方法的必然性

  • 定义格式

    • 格式1

      private 返回值类型 方法名(参数列表) { }

    • 范例1

      private void show() {  
}

    • 格式2

      private static 返回值类型 方法名(参数列表) { }

    • 范例2

      private static void method() {  
}

  • 注意事项

    • 默认方法可以调用私有的静态方法和非静态方法

    • 静态方法只能调用私有的静态方法

  • 什么是多态

    同一个对象，在不同时刻表现出来的不同形态

  • 多态的前提

    • 要有继承或实现关系

    • 要有方法的重写

    • 要有父类引用指向子类对象

  • 代码演示

    class Animal {
    public void eat(){
        System.out.println("动物吃饭");
    }
}

class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class Test1Polymorphic {
    /*
        多态的前提:

            1. 要有(继承 \ 实现)关系
            2. 要有方法重写
            3. 要有父类引用, 指向子类对象
     */
    public static void main(String[] args) {
        // 当前事物, 是一只猫
        Cat c = new Cat();
        // 当前事物, 是一只动物
        Animal a = new Cat();
        a.eat();

    }
}

  • 成员访问特点

    • 成员变量

      编译看父类，运行看父类

    • 成员方法

      编译看父类，运行看子类

  • 代码演示

    class Fu {
    int num = 10;

    public void method(){
        System.out.println("Fu.. method");
    }
}

class Zi extends Fu {
    int num = 20;

    public void method(){
        System.out.println("Zi.. method");
    }
}

public class Test2Polymorpic {
    /*
         多态的成员访问特点:

                成员变量: 编译看左边 (父类), 运行看左边 (父类)

                成员方法: 编译看左边 (父类), 运行看右边 (子类)
     */
    public static void main(String[] args) {
        Fu f = new Zi();
        System.out.println(f.num);
        f.method();
    }
}

  • 好处

    提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作

  • 弊端

    不能使用子类的特有成员

  • 向上转型

    父类引用指向子类对象就是向上转型

  • 向下转型

    格式：子类型 对象名 = (子类型)父类引用;

  • 代码演示

    class Fu {
    public void show(){
        System.out.println("Fu..show...");
    }
}

class Zi extends Fu {
    @Override
    public void show() {
        System.out.println("Zi..show...");
    }

    public void method(){
        System.out.println("我是子类特有的方法, method");
    }
}

public class Test3Polymorpic {
    public static void main(String[] args) {
        // 1. 向上转型 : 父类引用指向子类对象
        Fu f = new Zi();
        f.show();
        // 多态的弊端: 不能调用子类特有的成员
        // f.method();

        // A: 直接创建子类对象
        // B: 向下转型

        // 2. 向下转型 : 从父类类型, 转换回子类类型
        Zi z = (Zi) f;
        z.method();
    }
}

  • 风险

    如果被转的引用类型变量,对应的实际类型和目标类型不是同一种类型,那么在转换的时候就会出现ClassCastException

  • 解决方案

    • 关键字

      instanceof

    • 使用格式

      变量名 instanceof 类型

      通俗的理解：判断关键字左边的变量，是否是右边的类型，返回boolean类型结果

  • 代码演示

    abstract class Animal {
    public abstract void eat();
}

class Dog extends Animal {
    public void eat() {
        System.out.println("狗吃肉");
    }

    public void watchHome(){
        System.out.println("看家");
    }
}

class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class Test4Polymorpic {
    public static void main(String[] args) {
        useAnimal(new Dog());
        useAnimal(new Cat());
    }

    public static void useAnimal(Animal a){  // Animal a = new Dog();
                                             // Animal a = new Cat();
        a.eat();
        //a.watchHome();

//        Dog dog = (Dog) a;
//        dog.watchHome();  // ClassCastException  类型转换异常
      
        // 判断a变量记录的类型, 是否是Dog
        if(a instanceof Dog){
            Dog dog = (Dog) a;
            dog.watchHome();
        }
    }

}

  • 实现步骤

    1. StudentDaoFactory类中方法的返回值定义成父类类型BaseStudentDao

    2. StudentService中接收方法返回值的类型定义成父类类型BaseStudentDao

  • 代码实现

    StudentDaoFactory类

    public class StudentDaoFactory {
    public static BaseStudentDao getStudentDao(){
        return new OtherStudentDao();
    }
}

    StudentService类

    public class StudentService {
    // 创建StudentDao (库管)
    // private OtherStudentDao studentDao = new OtherStudentDao();

    // 通过学生库管工厂类, 获取库管对象
    private BaseStudentDao studentDao = StudentDaoFactory.getStudentDao();
}

  • 内部类概念

    • 在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类

  • 内部类定义格式

    • 格式&举例：

      /*
	格式：
    class 外部类名{
    	修饰符 class 内部类名{
    	
    	}
    }
*/

class Outer {
    public class Inner {
        
    }
}

  • 内部类的访问特点

    • 内部类可以直接访问外部类的成员，包括私有

    • 外部类要访问内部类的成员，必须创建对象

  • 示例代码：

    /*
    内部类访问特点：
        内部类可以直接访问外部类的成员，包括私有
        外部类要访问内部类的成员，必须创建对象
 */
public class Outer {
    private int num = 10;
    public class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    public void method() {
        Inner i = new Inner();
        i.show();
    }
}

  • 成员内部类的定义位置

    • 在类中方法，跟成员变量是一个位置

  • 外界创建成员内部类格式

    • 格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;

    • 举例：Outer.Inner oi = new Outer().new Inner();

  • 私有成员内部类

    • 将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。

    • 示例代码：

      class Outer {
    private int num = 10;
    private class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    public void method() {
        Inner i = new Inner();
        i.show();
    }
}
public class InnerDemo {
    public static void main(String[] args) {
		//Outer.Inner oi = new Outer().new Inner();
		//oi.show();
        Outer o = new Outer();
        o.method();
    }
}

  • 静态成员内部类

    • 静态成员内部类访问格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();

    • 静态成员内部类中的静态方法：外部类名.内部类名.方法名();

    • 示例代码

      class Outer {
    static class Inner {
        public void show(){
            System.out.println("inner..show");
        }

        public static void method(){
            System.out.println("inner..method");
        }
    }
}

public class Test3Innerclass {
    /*
        静态成员内部类演示
     */
    public static void main(String[] args) {
        // 外部类名.内部类名 对象名 = new 外部类名.内部类名();
        Outer.Inner oi = new Outer.Inner();
        oi.show();

        Outer.Inner.method();
    }
}

  • 局部内部类定义位置

    • 局部内部类是在方法中定义的类

  • 局部内部类方式方式

    • 局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用

    • 该类可以直接访问外部类的成员，也可以访问方法内的局部变量

  • 示例代码

    class Outer {
    private int num = 10;
    public void method() {
        int num2 = 20;
        class Inner {
            public void show() {
                System.out.println(num);
                System.out.println(num2);
            }
        }
        Inner i = new Inner();
        i.show();
    }
}
public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

  • 匿名内部类的前提

    • 存在一个类或者接口，这里的类可以是具体类也可以是抽象类

  • 匿名内部类的格式

    • 格式：new 类名 ( ) { 重写方法 } new 接口名 ( ) { 重写方法 }

    • 举例：

      new Inter(){
    @Override
    public void method(){}
}

  • 匿名内部类的本质

    • 本质：是一个继承了该类或者实现了该接口的子类匿名对象

  • 匿名内部类的细节

    • 匿名内部类可以通过多态的形式接受

      Inter i = new Inter(){
  @Override
    public void method(){
        
    }
}

  • 匿名内部类直接调用方法

    interface Inter{
    void method();
}

class Test{
    public static void main(String[] args){
        new Inter(){
            @Override
            public void method(){
                System.out.println("我是匿名内部类");
            }
        }.method();	// 直接调用方法
    }
}

  • 匿名内部类在开发中的使用

    • 当发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码

  • 示例代码：

    /*
    游泳接口
 */
interface Swimming {
    void swim();
}

public class TestSwimming {
    public static void main(String[] args) {
        goSwimming(new Swimming() {
            @Override
            public void swim() {
                System.out.println("铁汁, 我们去游泳吧");
            }
        });
    }

    /**
     * 使用接口的方法
     */
    public static void goSwimming(Swimming swimming){
        /*
            Swimming swim = new Swimming() {
                @Override
                public void swim() {
                    System.out.println("铁汁, 我们去游泳吧");
                }
            }
         */
        swimming.swim();
    }
}

  • 代码演示

    /*
    游泳接口
 */
interface Swimming {
    void swim();
}

public class TestSwimming {
    public static void main(String[] args) {
        // 通过匿名内部类实现
        goSwimming(new Swimming() {
            @Override
            public void swim() {
                System.out.println("铁汁, 我们去游泳吧");
            }
        });

        /*  通过Lambda表达式实现
            理解: 对于Lambda表达式, 对匿名内部类进行了优化
         */
        goSwimming(() -> System.out.println("铁汁, 我们去游泳吧"));
    }

    /**
     * 使用接口的方法
     */
    public static void goSwimming(Swimming swimming) {
        swimming.swim();
    }
}

  • 函数式编程思想概述

    在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿数据做操作”

    面向对象思想强调“必须通过对象的形式来做事情”

    函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”

    而我们要学习的Lambda表达式就是函数式思想的体现

  • 格式：

    (形式参数) -> {代码块}

    • 形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可

    • ->：由英文中画线和大于符号组成，固定写法。代表指向动作

    • 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容

  • 组成Lambda表达式的三要素：

    • 形式参数，箭头，代码块

  • Lambda表达式的使用前提

    • 有一个接口

    • 接口中有且仅有一个抽象方法

  • 练习描述

    无参无返回值抽象方法的练习

  • 操作步骤

    • 定义一个接口(Eatable)，里面定义一个抽象方法：void eat();

    • 定义一个测试类(EatableDemo)，在测试类中提供两个方法

      • 一个方法是：useEatable(Eatable e)

      • 一个方法是主方法，在主方法中调用useEatable方法

  • 示例代码

    //接口
public interface Eatable {
    void eat();
}
//实现类
public class EatableImpl implements Eatable {
    @Override
    public void eat() {
        System.out.println("一天一苹果，医生远离我");
    }
}
//测试类
public class EatableDemo {
    public static void main(String[] args) {
        //在主方法中调用useEatable方法
        Eatable e = new EatableImpl();
        useEatable(e);

        //匿名内部类
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("一天一苹果，医生远离我");
            }
        });

        //Lambda表达式
        useEatable(() -> {
            System.out.println("一天一苹果，医生远离我");
        });
    }

    private static void useEatable(Eatable e) {
        e.eat();
    }
}

  • 练习描述

    有参无返回值抽象方法的练习

  • 操作步骤

    • 定义一个接口(Flyable)，里面定义一个抽象方法：void fly(String s);

    • 定义一个测试类(FlyableDemo)，在测试类中提供两个方法

      • 一个方法是：useFlyable(Flyable f)

      • 一个方法是主方法，在主方法中调用useFlyable方法

  • 示例代码

    public interface Flyable {
    void fly(String s);
}

public class FlyableDemo {
    public static void main(String[] args) {
        //在主方法中调用useFlyable方法
        //匿名内部类
        useFlyable(new Flyable() {
            @Override
            public void fly(String s) {
                System.out.println(s);
                System.out.println("飞机自驾游");
            }
        });
        System.out.println("--------");

        //Lambda
        useFlyable((String s) -> {
            System.out.println(s);
            System.out.println("飞机自驾游");
        });

    }

    private static void useFlyable(Flyable f) {
        f.fly("风和日丽，晴空万里");
    }
}

  • 练习描述

    有参有返回值抽象方法的练习

  • 操作步骤

    • 定义一个接口(Addable)，里面定义一个抽象方法：int add(int x,int y);

    • 定义一个测试类(AddableDemo)，在测试类中提供两个方法

      • 一个方法是：useAddable(Addable a)

      • 一个方法是主方法，在主方法中调用useAddable方法

  • 示例代码

    public interface Addable {
    int add(int x,int y);
}

public class AddableDemo {
    public static void main(String[] args) {
        //在主方法中调用useAddable方法
        useAddable((int x,int y) -> {
            return x + y;
        });

    }

    private static void useAddable(Addable a) {
        int sum = a.add(10, 20);
        System.out.println(sum);
    }
}

  • 省略的规则

    • 参数类型可以省略。但是有多个参数的情况下，不能只省略一个

    • 如果参数有且仅有一个，那么小括号可以省略

    • 如果代码块的语句只有一条，可以省略大括号和分号，和return关键字

  • 代码演示

    public interface Addable {
    int add(int x, int y);
}

public interface Flyable {
    void fly(String s);
}

public class LambdaDemo {
    public static void main(String[] args) {
//        useAddable((int x,int y) -> {
//            return x + y;
//        });
        //参数的类型可以省略
        useAddable((x, y) -> {
            return x + y;
        });

//        useFlyable((String s) -> {
//            System.out.println(s);
//        });
        //如果参数有且仅有一个，那么小括号可以省略
//        useFlyable(s -> {
//            System.out.println(s);
//        });

        //如果代码块的语句只有一条，可以省略大括号和分号
        useFlyable(s -> System.out.println(s));

        //如果代码块的语句只有一条，可以省略大括号和分号，如果有return，return也要省略掉
        useAddable((x, y) -> x + y);
    }

    private static void useFlyable(Flyable f) {
        f.fly("风和日丽，晴空万里");
    }

    private static void useAddable(Addable a) {
        int sum = a.add(10, 20);
        System.out.println(sum);
    }
}

  • 使用Lambda必须要有接口

  • 并且要求接口中有且仅有一个抽象方法

  • 所需类型不同

    • 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类

    • Lambda表达式：只能是接口

  • 使用限制不同

    • 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类

    • 如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式

  • 实现原理不同

    • 匿名内部类：编译之后，产生一个单独的.class字节码文件

    • Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

Java后端程序员知识库
关注
专栏目录
接口与继承系列教材 （十）- Java 内部类详解
weixin_50279139的博客
09-24 147
接口与继承系列教材 （十）- Java 内部类详解 内部类分为四种： 非静态内部类 静态内部类 匿名类 本地类 步骤1:非静态内部类步骤2:静态内部类步骤3:匿名类步骤4:本地类步骤5:在匿名类中使用外部的局部变量步骤6:练习-内部类步骤7:答案-内部类 步骤1:非静态内部类 非静态内部类 BattleScore “战斗成绩” 非静态内部类可以直接在一个类里面定义 比如： 战斗成绩只有在一个英雄对象存在的时候才有意义 所以实例化BattleScore 的时候，必须建立在一个存在的英雄的基础上 ...
继承内部类
sarah的博客
07-15 432
最近刚好碰到一个场景，需要继承某个类的内部类。Thinking in Java是这样描述的: Because theinner-class constructor must attach to a reference of the enclosing classobject, things are slightly complicated when you inherit from an in
内部类的继承
qq_36777191的博客
01-13 1171
内部类可以是abstract和final类型，也可以是接口。类可由其他内部类继承，接口则可由其他的内部类实现。此处讲述内部类继承，内部类继承通常有三种： 一、同一外包类中的内部类之间的继承 如：A.Innerclass_child 继承 A.Innerclass_parent eg: class outer{     class inner_1{         public inner(S...
内部类继承
miracleon的博客
09-17 782
本文主要以成员内部类 为讲解对象 本文要点如下： 成员内部类的子类可以是内部类，也可以不是内部类； 当成员内部类的子类不是内部类或子类虽是内部类但与其父类不在同一个外部类时，子类的构造方法第一句要显式添加如下的语句： 外部类对象引用.super(参数); 这里的外部类指父类所在的外部类 编译器默认给成员内部类的构造方法传入一个参数，该参数是内部类所依附的外部类对象的引用； 注：本文涉及到的类都...
Java继承——内部类
最新发布
Datoulu1的博客
06-08 299
定义：在一个类里面，再定义一个类什么时候用到：B类是A类的一部分，且B类单独存在没有意义，内部类的访问特点：1，内部类可以直接访问外部类的成员，包括它的私有方法2，外部类要访问内部类的成员，必须创建对象写在成员的内部类，在类中，方法外。
2022年接口内部类和JavaAPI基础.ppt
11-03
"2022年接口内部类和JavaAPI基础" 一、接口 1.1 声明接口 ...本节课我们学习了Java中的接口、内部类和内部接口，了解了它们的声明、实现和使用方法，以及Java API基础的包中的基础类库和工具类库。
Java的接口、内部类、常用类
12-22
JAVA接口、内部类、常用类 一、JAVA接口 1.1 什么是接口？: 接口相当于特殊的抽象类，定义方式、组成部分于抽象类类似。 微观概念:接口是一种能力和约定 接口的定义:代表了某种能力 方法的定义:能力的具体要求 经验:...
接口，内部类，抽象类概念和区别
03-21
3. **访问权限**：内部类能访问外部类的所有成员，而接口和抽象类只能通过继承或实现来访问。 4. **用途**：接口主要用于定义行为规范，确保多态性；抽象类用于提供基类，减少代码重复，实现部分功能；内部类则用于...
IDEA中查看类继承图和类源码的骚操作
08-25
IDEA中查看类继承图和类源码的骚操作 IDEA是一款功能强大且广泛使用的集成开发环境...IDEA中查看类继承图和类源码的骚操作可以帮助我们快速了解一个类的继承结构和内部结构，提高我们的开发效率和调试能力。
接口--内部类--多继承
04-07
在Java编程语言中，接口和内部类是两种重要的特性，它们分别用于实现多态性和封装。接口是一种定义行为规范的抽象类型，而内部类则提供了一种在类中嵌套其他类的方式，增强了代码的组织性和隐私性。多继承则是Java中...
Java内部类的继承（全）
09-03
主要介绍了Java内部类的继承，大家都知道JAVA内部类的构造器必须连接指向其外围类对象的引用，所以在继承内部类的时候，需要在导出类的构造器中手动加入对基类构造器的调用,需要的朋友可以参考下
匿名内部类是否可以继承其它类是否可以实现接口 _JAVA面试题及答案
JAVA大师
01-05 396
Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)? 答案： 可以继承其他类或完成其他接口，在swing编程中常用此方式。...
java继承内部类
现在渣不代表我永远渣= =
05-04 513
测试了下一个类继承内部类
Java内部类的继承
weixin_30677617的博客
07-28 136
Java内部类的构造器必须连接到指向其外围类对象的引用（构造内部类必须给它一个外部类对象的引用，内部类依赖于外部类对象），所以在继承内部类的时候，需要在导出类的构造器中手动加入对基类构造器的调用。 因为，在导出类实例化时，并不存在一个外围类对象，以让导出类的实例去连接到它。 所以，我们需要创建一个外围类，然后用一个特定的语法来表明内部类与外围类的关系。 在下例子中，需要给导出类I...
Java 继承内部类
weixin_30644369的博客
10-16 70
大家有没有想过内部类究竟能不能被继承呢？ public class Main { public static void main(String[] args){ Outer outer = new Outer(); Extender extender = new Extender(outer); } } class Outer{ class...
Java-内部类的创建及继承
qq_39495331的博客
12-29 415
一.非静态内部类 非静态内部类的初始化需要其外部类的环境，所以在初始化非静态内部类的时候需要外部类实例才行，具体格式： /** * @author mojiayi * @date 2018-12-29 16:50 */ public class Outer { class Inner{ } public static void main(String[] a...
Java—内部类（三）—内部类的继承
热门推荐
devY的博客
12-14 1万+
内部类的继承内部类和其他普通类一样，同样可以被继承，这样给本来就十分灵活的内部类增加了更好的结构性和代码复用性。只是内部类的继承和普通类有一些不同之处，是在使用时需要多加注意的。因为内部类在创建时需要外部类的引用，所以在内部类的继承上也需要外部类的协助。
内部类可以被继承
zhengun的专栏
06-06 1126
/** 成员内部类 作为外部类的一个成员存在，与外部类的属性、方法并列。 */ package Outer; public class Outer { private static int i = 1; private int j = 10; private int k = 20; public static void o...
内部类的继承问题
Allence的博客
03-04 2663
成员内部类可以继承其他的类，也可以被其它类继承，本文主要说明其它类继承成员内部类的问题。 本文要点如下： 1).成员内部类的子类可以是内部类，也可以不是内部类； 2).当成员内部类的子类不是内部类或子类虽是内部类但与其父类不在同一个外部类时，子类的构造方法第一句要显式添加如下的语句： 外部类对象引用.super(参数); 这里的外部类指父类所在的外部类； 3).编译器默认给成员内部类的构造方法传入一个参数，该参数是内部类所依附...
Java接口与内部类详解：实现多重继承的机制
"本资源主要介绍了Java编程中的接口、内部类和Java API基础知识，强调了接口在...理解并熟练使用接口和内部类是掌握Java编程的关键，同时熟悉Java API能够帮助开发者更高效地利用现有资源，创建功能丰富的应用程序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值