04—面向对象进阶

嗨饼干

于 2023-07-01 19:24:07 发布

阅读量50

点赞数

分类专栏： Java进阶文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_45161115/article/details/131404471

版权

Java进阶专栏收录该内容

13 篇文章 0 订阅

订阅专栏

static关键字

1.1 概述

static表示静态的意思，static可以修饰成员变量和成员方法。

被static修饰的成员变量称为静态成员变量，属于类。该变量在内存中只会存储一份，可以被共享访问、修改。

// 静态成员变量的使用
类名.静态成员变量;		//推荐方式
对象名.静态成员变量;		//不推荐

被static修饰的方法称为静态成员方法，属于类。

// 静态成员方法的使用
类名.静态成员方法();	//推荐方式
对象名.静态成员方法();	//不推荐

1.2 注意事项

静态方法只能访问静态成员，不可以直接访问非静态成员（实例成员）
实例方法可以访问静态成员也可以访问实例成员
静态方法中不可以出现this关键字

1.3 应用知识

1.3.1 工具类

类中都是一些静态方法，每个方法都是以一个完成一个共用的功能为目的。这个类用于给系统开发人员共同使用，例如：获取验证码工具类

package com.spark.study;

import java.util.Random;

/**
 * YzCodeUtil class
 * description: static应用——验证码工具类
 *
 * @author Administrator
 * @date 2023/1/26
 */
public class YzCodeUtil {
    /**
     * 构造方法私有化
     */
    private YzCodeUtil(){

    }

    /**
     * 获取验证码
     * @return
     */
    public static String getCode(){
        String code = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        String result = "";
        // 获取四位验证码
        Random random = new Random();
        for(int i=0;i<4;i++){
            result+= code.charAt(random.nextInt(code.length()));
        }
        return result;
    }
    
}

1.3.2 代码块

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

静态代码块
- 格式：static{}
- 特点：需要通过static关键字进行修饰，随着类的加载而加载，并且自动触发，只执行一次
- 使用场景：在类加载的时候做一些静态数据初始化操作，以便于后续使用
实例代码块
- 格式：{}
- 特点：每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行
- 使用场景：初始化实例资源
- 例如：斗地主游戏开始前，为游戏组装一副扑克牌

package com.spark.study;

import java.util.ArrayList;

/**
 * StaticCode class
 * description: 静态代码块
 *
 * @author Administrator
 * @date 2023/1/26
 */
public class StaticCode {
    static ArrayList<String> list = new ArrayList<String>();
    static String [] numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
    static String [] colors = {"♥","♠","♣","♦"};
    /**
     * 静态代码块初始化扑克牌
     */
    static{
        //组装牌
        for (String number : numbers) {
            for (String color : colors) {
                String str = color+number;
                list.add(str);
            }
        }
        list.add("大王");
        list.add("小王");
    }

    public static void main(String[] args) {
        System.out.println(list);
    }
}

1.3.3 单例设计模式

可以保证系统中，应用该模式的类永远只有一个实例，即一个类永远只能创建一个对象

例如：任务管理器对象只需要创建一个就可以解决问题了，这样可以节省内存空间

单例设计模式的示例：饿汉式、懒汉式

① 饿汉式单例模式：在调用类之前，类提供好了对象

package com.spark.study;

/**
 * StaticDesign01 class
 * description: 单例设计模式——饿汉单例模式
 *
 * @author Administrator
 * @date 2023/1/26
 */
public class StaticDesign01 {
    // 1.构造器私有化
    private StaticDesign01(){

    }
    // 2.创建一个对象，用于向外提供对象
    public static StaticDesign01 staticDesign01 = new StaticDesign01();
    
}

② 懒汉单例模式：在真正需要该类时再创建对象

package com.spark.study;

/**
 * StaticDesign02 class
 * description: 单例设计模式——懒汉单例模式
 *
 * @author Administrator
 * @date 2023/1/26
 */
public class StaticDesign02 {
    // 1.构造方法私有化
    private StaticDesign02(){
        
    }
    // 2.提供一个私有的静态变量存储单例对象
    private static StaticDesign02 design;
    
    // 3.提供一个静态方法向外返回单例对象
    public static StaticDesign02 getInstance(){
        if(design == null){
            design = new StaticDesign02();
        }
        return design;
    }
}

继承

2.1 概述

什么是继承？

Java中通过extends关键字，可以让一个类和另一个类建立起父子关系

当子类继承父类时，可以使用父类中的公共的属性和方法

继承的优点

减少代码冗余，提高代码的复用性
增强类的功能扩展性

2.2 继承的设计规范

子类们相同的特征（共性属性，共性方法）放在父类中定义，子类独有的属性和行为应该定义在子类里面

例如：使用继承关系设计学生和老师

学生：姓名、性别、年龄、上课、介绍

老师：姓名、性别、年龄、讲课、介绍

可以将二者共同的属性和行为抽取出来作为一个基类用于扩展

Person：姓名、性别、年龄、介绍

Student：上课

Teacher：讲课

package com.spark.study;

/**
 * Person class
 * description: 父类
 *
 * @author Administrator
 * @date 2023/1/26
 */
public class Person {
    /**
     * 公共属性
     */
    private String name;
    private int age;
    private String sex;

    /**
     * 公共方法
     */
    public void introduce(){
        System.out.println("你好，我是"+name);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

package com.spark.study;

/**
 * Student class
 * description: 子类
 *
 * @author Administrator
 * @date 2023/1/26
 */
public class Student extends Person{
    /**
     * 学生类特有的方法
     */
    public void study(){
        System.out.println(getName()+"正在上课");
    }
}

package com.spark.study;

/**
 * Teacher class
 * description: 教师类
 *
 * @author Administrator
 * @date 2023/1/26
 */
public class Teacher extends Person{
    /**
     * 老师类特有的方法
     */
    public void teach(){
        System.out.println(getName()+"正在讲课");
    }
}

2.3 特点

子类可以继承父类的属性和方法，但是子类不能继承父类的构造器
Java是单继承，一个类只能有一个直接父类
Java不支持多继承，但是支持多层继承
Java中所有的类都是Object类的子类

2.4 成员变量和成员方法访问

子类中成员变量和成员方法满足 就近原则

先在子类局部范围找
然后子类成员范围找
然后父类成员范围找，如果父类范围还没有找到则报错

如果子父类中出现了重名的成员，会优先使用子类，此时如果一定要在子类中使用父类成员，可以使用 super 关键字指定访问父类的成员。

package com.spark.fieldmethod;

/**
 * Animal class
 * description: 子类继承父类访问父类成员
 *
 * @author Administrator
 * @date 2023/2/5
 */
public class Animal {

    public String name = "动物名称";

    public void run(){
        System.out.println("动物会跑...");
    }
}

package com.spark.fieldmethod;

/**
 * Cat class
 * description: 子类继承父类访问父类成员
 *
 * @author Administrator
 * @date 2023/2/5
 */
public class Cat extends Animal{

    public void run(){
        System.out.println("小猫快跑。。。");
    }
    public void show(){
        // 调用子类成员方法
        run();
        // 调用父类成员方法
        super.run();
        // 调用父类成员属性
        System.out.println(super.name);
    }
}

2.5 方法重写

当子类出现和父类一样的方法声明即（方法名、参数列表、返回值类型）该方法是重写的方法

方法重写的应用场景：当子类需要父类的功能，但是父类的功能无法满足子类需求。

package com.spark.methodoverride;

/**
 * Phone class
 * description: 方法重写——父类
 *
 * @author Administrator
 * @date 2023/2/5
 */
public class Phone {
    public void call(){
        System.out.println("打电话...");
    }
    public void sendMessage(){
        System.out.println("发短信...");
    }
}

package com.spark.methodoverride;

/**
 * NewPhone class
 * description: 方法重写——子类
 *
 * @author Administrator
 * @date 2023/2/5
 */
public class NewPhone extends Phone{
    @Override // 重写校验注解
    public void call(){
        super.call();
        System.out.println("新手机添加了视频通话功能！");
    }
    @Override // 重写校验注解
    public void sendMessage(){
        super.sendMessage();
        System.out.println("新手机添加了发送图片功能！");
    }
}

@Override注解

@Override注解是放在重写方法上，作为重写是否正确的校验注解
加上该注解如果重写错误，编译阶段会出现错误提示

方法重写的注意事项和要求

重写方法的名称、形参列表必须要重写的方法名称和参数列表一致
私有方法不能重写
子类重写方法时，访问权限必须大于等于父类方法权限
子类不能重写父类静态方法

包

包是用来分门别类的管理各种不同的类，类似于文件夹、建包有利于程序的管理和维护

3.1 建包

建包的语法格式：package 公司域名倒序.技术名称。包名建议全部英文小写，且具备意义

package com.spark.entity;
public class Student{
    
}

建包语句必须写在第一行，一般创建类时会自动生成

3.2 导包

相同包下的类可以直接访问，不同包下访问需要进行导入包操作

导包的格式：import 包名.类名;

假如一个类中需要用到不同的类，而这些类的名称又是相同的，那么默认只能导入一个类，另外的类需要全名访问即带包名访问

权限修饰符

权限修饰符：用来控制一个成员能够被访问的范围

可以修饰成员变量，方法，构造器，内部类，不同权限修饰符修饰的成员能够被访问的范围受到限制。

权限修饰符的分类和具体作用范围：

修饰符	同一类中	同一个包下的其他类	不同包下的子类	不同包下的其他类
private	√
default	√	√
protected	√	√	√
public	√	√	√	√

final

final是最终的意思，可以修饰类，方法，变量

修饰类：被修饰的类不能被继承
修饰方法：被修饰的方法不能被重写
修饰变量：被修饰的变量第一次赋值后，值不可更改

final修饰的变量注意点：

final修饰的变量如果是基本数据类型，那么变量存储的数据值不能发生改变
final修饰的变量如果是引用数据类型，那么变量存储的地址不能发生改变，但是地址指向的对象内容可以发生改变

package com.spark.study;

/**
 * FinalTest class
 * description: final修饰的变量
 *
 * @author Administrator
 * @date 2023/2/12
 */
public class FinalTest {
    public static void main(String[] args) {
        // 1.final修饰局部变量
        final double PI = 3.14;
        // final修饰的变量如果是基本数据类型，则值不可二次更改
        //PI = 3.1415926;

        // 2.final修饰类
        final Student student = new Student("打篮球");
        // final修饰的类不能更改地址，但是可以更改地址对应对象的内容
        //student = new Student("画画");
        student.setHobby("画画");
        System.out.println(student.getHobby());
    }
}
class Student{
    private String hobby;

    public Student(String hobby) {
        this.hobby = hobby;
    }

    public String getHobby() {
        return hobby;
    }

    public void setHobby(String hobby) {
        this.hobby = hobby;
    }
}

常量

常量是使用了 public static final 修饰的成员变量，必须有初始值，而且执行过程中其值不能被改变。可以用于做系统的配置信息，方便程序维护，同时也提高可读性。

常量的命名规范：英文单词全部大写；多个单词下划线连接起来。

// 常量定义
public class CommonContent{
    public static final String RESPONSE_CODE_SUCCESS = "0000";
    public static final String RESPONSE_MESSAGE_SUCCESS = "操作成功";
}

常量的基本使用：

package com.spark.study;

import java.util.Scanner;

/**
 * FinalTest2 class
 * description: TODO
 *
 * @author Administrator
 * @date 2023/2/12
 */
public class FinalTest2 {
    // 定义常量
    public static final String RIGHT_PASSWORD = "123456";
    public static final String RESPONSE_MESSAGE_SUCCESS = "登录成功！";
    public static final String RESPONSE_MESSAGE_ERROR = "登录失败";
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("欢迎登录学生管理系统~~~~~~~~~~~~~~~~");
        System.out.println("请输入您的登录密码：");
        String password = scanner.next();
        if(password.equals(RIGHT_PASSWORD)){
            System.out.println(RESPONSE_MESSAGE_SUCCESS);
        }else{
            System.out.println(RESPONSE_MESSAGE_ERROR);
        }

    }
}

抽象类

在Java中关键字 abstract 是抽象的意思，可以修饰类和方法

abstract修饰的类为抽象类；abstract修饰的方法为抽象方法

7.1 基本使用

抽象类和抽象方法的语法格式：

// 抽象类
访问修饰符 abstract class 类名{
    
}
// 抽象方法
访问修饰符 abstract 返回值类型 方法名(参数列表){
    
}

注意事项：

抽象方法没有方法体，只有方法签名
如果类中定义了抽象方法，该类必须是抽象类
如果一个类继承了抽象类，该类必须重写抽象类中的全部抽象方法，否则该类也必须定义为抽象类

使用场景：

抽象类可以理解成一个设计图，一般作为父类让子类继承后去实现
当父类知道子类一定要完成某些行为时，但是每个子类完成行为的实现又不同，这时父类就可以声明为抽象类，将行为声明为抽象方法，具体实现交给子类完成

package com.spark.study;

/**
 * Animal class
 * description: 抽象类
 *
 * @author Administrator
 * @date 2023/2/19
 */
// 抽象类
public abstract class Animal {

    // 抽象方法
    public abstract void run();
}

package com.spark.study;

/**
 * Dog class
 * description: 子类继承抽象类实现抽象方法
 *
 * @author Administrator
 * @date 2023/2/19
 */
public class Dog extends Animal{
    // 实现抽象方法
    @Override
    public void run() {
        System.out.println("小狗快跑...");
    }
}

package com.spark.study;

/**
 * Test class
 * description: TODO
 *
 * @author Administrator
 * @date 2023/2/19
 */
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.run();
    }
}

7.2 案例

某加油站推出了一中支付卡，预存10000的金卡，后续加油享受8折优惠。请实现卡片进入收银系统后的逻辑，卡片需要包含主人名称，金额，支付功能

① 支付卡定义

package com.spark.examples;

/**
 * Card class
 * description: 抽象类
 *
 * @author Administrator
 * @date 2023/2/19
 */
public abstract class Card {
    // 主人姓名
    private String userName;
    
    // 卡余额
    private double money;
    
    // 抽象方法
    public abstract void pay(double money);

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

② 金卡实现抽象方法

package com.spark.examples;

/**
 * GoldCard class
 * description: 子类
 *
 * @author Administrator
 * @date 2023/2/19
 */
public class GoldCard extends Card{

    // 实现支付功能
    @Override
    public void pay(double money) {
        System.out.println("欢迎您,"+getUsername()+"先生/女士");
        System.out.println("您当前消费:"+money);
        // 优惠
        money = money* 0.8;
        System.out.println("实际消费:"+money);
        // 余额
        setMoney(getMoney()-money);
        System.out.println("卡剩余:"+getMoney());
    }
}

7.3 特征及注意事项

类有的成员（成员变量、成员方法、构造器）抽象类也具备
抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
一个类继承了抽象类必须全部重写抽象类中的方法，否则这个类也必须定义为抽象类
不能用abstract修饰变量、构造器、代码块
抽象类不能进行实例化操作

abstract和final关键字的关系

互斥关系

当final修饰类时，该类不能被继承；当abstract修饰类时，该类可以被继承
当final修饰方法时，方法不能被重写；当abstract修饰方法时，子类需要重写父类的抽象方法

7.4 模板方法设计模式

使用场景：当系统中出现同一个功能多处在开发，而该功能大多数代码一样，只有其中部分可能不同的时候。

模板方法的实现步骤：

把功能定义成一个所谓的模板方法，放在抽象类中，模板方法只定义通用且确定的代码
模板方法中不能决定的功能作为抽象方法让具体子类去实现

案例：现在有两类学生，一类是中学生，一类是初中生，他们都要写《给父亲的一封信》，要求每类学生的标题第一段和最后结尾内容必须一样，正文自己发挥。

package com.spark.examples;

/**
 * Student class
 * description: 模板方法——父类
 *
 * @author Administrator
 * @date 2023/2/19
 */
public abstract class Student {
    
    // 抽象方法
    public abstract String writeMain(String content); //写正文
    
    // 模板方法
    public final void write(String content){
        // 通用开头
        System.out.println("亲爱的老爸，你好");
        // 正文
        System.out.println(writeMain(content));
        // 结尾
        System.out.println("老爸我爱你。");
    }
}

package com.spark.examples;

/**
 * StudentMiddle class
 * description: 模板方法——中学生
 *
 * @author Administrator
 * @date 2023/2/19
 */
public class StudentMiddle extends Student{

    // 写正文
    @Override
    public String writeMain(String content) {
        return content;
    }
}

package com.spark.examples;

/**
 * StudentStartMiddle class
 * description: 模板方法——初中生
 *
 * @author Administrator
 * @date 2023/2/19
 */
public class StudentStartMiddle extends Student{

    // 写正文
    @Override
    public String writeMain(String content) {
        return content;
    }
}

接口

接口通过 interface 关键字去定义

语法格式：

public interface 接口名{
    // 常量
    // 抽象方法
}

JDK1.8之前，接口内容只有两部分，常量和抽象方法

8.1 基本使用

接口是用来被类实现的，实现接口的类为实现类。类可以实现多个接口

package com.spark.study;

// 接口
public interface Sport {
    void run(); // 抽象方法
}

package com.spark.study;

public interface Life {
    void eat();
    void sleep();
}

package com.spark.study;

/**
 * RunningMan class
 * description: 运动员
 *
 * @author Administrator
 * @date 2023/2/19
 */
// 实现多接口
public class RunningMan implements Sport ,Life{
    private String name;

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

    @Override
    public void eat() {
        System.out.println(name + "在休息时间用餐。");
    }

    @Override
    public void sleep() {
        System.out.println(name + "结束了今天的训练回家睡觉");
    }

    @Override
    public void run() {
        System.out.println(name + "在训练跑步");
    }
}

8.2 接口与接口的关系

类与类的关系是 单继承
类与接口的关系是 多实现
接口与接口的关系是 多继承

一个接口可以同时继承多个接口

继承多个接口的作用：规范合并，整合多个接口为同一个接口，便于子类实现

8.3 JDK8新增方法

实例方法，使用default修饰，通过实现类实例化后调用
静态方法，只能通过接口名.方法名进行调用
JDK9新增私有方法，只能在接口内部进行访问

多态

9.1 基本使用

同一类型的对象，对于同一行为会表现出不同的行为特征

语法格式：

父类类型 对象名 = new 子类构造器(参数列表);
接口	对象名 = new 实现类构造器;

① 父类指向子类对象

package com.spark.study;

/**
 * Animal class
 * description: 父类
 *
 * @author Administrator
 * @date 2023/2/22
 */
public class Animal {
    String name = "动物名称";
    public void run(){
        System.out.println("动物可以跑");
    }
}

package com.spark.study;

/**
 * Dog class
 * description: 子类
 *
 * @author Administrator
 * @date 2023/2/22
 */
public class Dog extends Animal{
    String name = "狗";

    @Override
    public void run() {
        System.out.println("狗跑的很快~~~");
    }
}

package com.spark.study;

/**
 * Ribbit class
 * description: 子类
 *
 * @author Administrator
 * @date 2023/2/22
 */
public class Ribbit extends Animal{
    String name = "兔子";

    @Override
    public void run() {
        System.out.println("兔子跳的很快~~~");
    }
}

package com.spark.study;

/**
 * Test01 class
 * description: 父类指向子类对象
 *
 * @author Administrator
 * @date 2023/2/22
 */
public class Test01 {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.run();
        System.out.println(animal.name);

        Animal animal2 = new Ribbit();
        animal2.run();
        System.out.println(animal2.name);
    }
}

② 实现类实现接口

package com.spark.study;

// 接口
public interface Person {
    // 实现方法
    void eat();
    void sleep();
}

package com.spark.study;

/**
 * Student class
 * description: 实现类
 *
 * @author Administrator
 * @date 2023/2/22
 */
public class Student implements Person{
    @Override
    public void eat() {
        System.out.println("学生开始去食堂吃饭");
    }

    @Override
    public void sleep() {
        System.out.println("学生熄灯开始睡觉");
    }
}

package com.spark.study;

/**
 * Test02 class
 * description: TODO
 *
 * @author Administrator
 * @date 2023/2/22
 */
public class Test02 {
    public static void main(String[] args) {
        Person person = new Student();
        person.eat();
        person.sleep();
    }
}

多态中成员访问特点：

方法调用：编译看左边，运行看右边
变量调用：编译看左边，运行看左边

多态的前提：

有继承/实现关系
父类引用指向子类对象
有方法的重写

9.2 多态的优势与劣势

优势：

① 在多态的形式下，右边的对象可以实现解耦合，便于扩展和维护

// 父类引用指向子类对象
Animal animal = new Dog();
// 表现子类对象的行为特征
a.run(); //后续业务随对象改变，只需要更改指向的子类对象，后续代码无需更改

② 定义方法时，使用父类型作为参数，该方法可以接收这父类的一切子类对象，体现出多态的扩展性和便利。

public class Test{
    public static void main(String [] args){
        // Animal子类对象
        Dog dog = new Dog();
        go(dog);
        
        // Animal子类对象
        Cat cat = new Cat();
        go(cat);
    }
    // 接收任意的动物
    puiblic static void go(Animal animal){
        System.out.println("比赛跑~~~~");
    }
}

劣势：多态下不能使用子类的独有功能

9.3 引用数据类型的数据转换

向上转型：子类对象赋值给父类类型的变量指向

向下转型：父类对象赋值给子类类型的变量指向

必须进行强制类型转换子类对象名 = (子类)父类对象名;
作用可以解决多态下的劣势，可以实现子类独有的功能
如果转型后的类型和对象真实类型不是同一种类型，那么在转换的时候会出现ClassCastException

Animal animal = new Dog();
Cat cat = (Cat)animal; // 出现类型转换异常 狗类型无法转换成猫类型

Java建议转换之前可以用 instanceof 判断当前对象的真实类型，再进行强制类型转换

/*
	判断关键字左边的变量指向的对象类型，是否是右边类型或者其子类型，是则返回true
*/
对象名 instanceof 真实类型

内部类

10.1 概述

内部类就是一个定义在类里面的类，类名的类可以理解为寄生类，外面的类可以理解为宿主

public class Person{
    // 内部类
    public class Heart{
        
    }
}

内部类的使用场景和作用：

当一个事物的内部，还有一部分需要一个完整的结构进行描述，而这个内部的完整结构又只为外部事物提供服务，那么整个内部的完整结构可以选择使用内部类进行设计
内部类通常可以方便访问外部类的成员，包括私有成员
内部类提供了更好的封装性，内部类本身就可以用private protected等修饰，封装性可以做更多控制

内部类的分类：

静态内部类
成员内部类
局部内部类
匿名内部类

10.2 静态内部类

被static修饰的内部类为静态内部类，静态内部类与非静态内部类无差别，只是位置不同

静态内部类调用格式：

// 创建对象
外部类.静态内部类 对象名 = new 外部类.静态内部类构造器(构造器参数列表);
对象名.方法名();

基本使用：

package com.spark.innerclass;

/**
 * Person class
 * description: 静态内部类
 *
 * @author Administrator
 * @date 2023/2/26
 */
public class Person {

    private static Integer count = 70;

    // 静态内部类
    public static class Heart{

        // 成员属性
        private String location;

        private String blood;

        // 构造器
        public Heart(){

        }
        public Heart(String location, String blood){
            this.location = location;
            this.blood = blood;
        }

        // 成员方法
        public void live(){
            System.out.println("心脏是人类重要的器官");
            System.out.println("心脏每分钟跳动"+count+"次");
        }
        public String getLocation() {
            return location;
        }

        public void setLocation(String location) {
            this.location = location;
        }

        public String getBlood() {
            return blood;
        }

        public void setBlood(String blood) {
            this.blood = blood;
        }
    }
}

package com.spark.innerclass;

/**
 * Test class
 * description:
 *
 * @author Administrator
 * @date 2023/2/26
 */
public class Test {
    public static void main(String[] args) {
        Person.Heart heart = new Person.Heart();
        heart.live();
    }
}

静态内部类可以直接访问外部类的静态成员，不能直接访问外部类的非静态成员。

10.3 成员内部类

无static修饰，属于外部类对象

JDK16之前，成员内部类中不能定义静态成员，JDK16开始也可以定义静态成员

成员内部类调用格式：

// 创建对象
外部类.内部类 对象名 = new 外部类构造器(参数列表).new 内部类构造器(参数列表);
// 调用方法
对象名.方法名();

基本使用：

package com.spark.innerclass;

/**
 * Car class
 * description: 成员内部类
 *
 * @author Administrator
 * @date 2023/2/26
 */
public class Car {
    private static String name = "宝马";

    private double price;

    public Car(){

    }
    public Car(double price){
        this.price = price;
    }

    // 内部类
    public class Parts{
        // 成员属性
        private String partsName;

        // 构造器
        public Parts(){

        }
        public Parts(String partsName){
            this.partsName = name;
        }

        // 成员方法
        public void show(){
            // 直接访问外部类成员变量
            System.out.println("车的品牌:"+Car.name);
            System.out.println("车的价格:"+price+"万元");
            // 访问内部类成员
            System.out.println("要加装的零件是"+this.partsName);
        }
    }
}

package com.spark.innerclass;

/**
 * Test2 class
 * description:
 *
 * @author Administrator
 * @date 2023/2/26
 */
public class Test2 {
    public static void main(String[] args) {
        // 创建内部类对象
        Car.Parts parts = new Car(50).new Parts("发动机");
        // 调用内部类方法
        parts.show();
    }
}

成员内部类可以直接访问外部类的静态成员与非静态成员；JDK16之前，成员内部类不能定义静态成员

10.4 局部内部类（了解）

局部内部类放在方法、代码块、构造器等执行体中。基本不用

package com.spark.innerclass;

/**
 * Test3 class
 * description:
 *
 * @author Administrator
 * @date 2023/2/26
 */
public class Test3 {
    public static void main(String[] args) {
        // 局部内部类
        class Cat{
            private String name;
            private int month;

            public Cat(String name, int month){
                this.name = name;
                this.month = month;
            }
        }
        // 创建对象
        Cat cat = new Cat("花花",5);
        System.out.println(cat.name + "今年"+cat.month+"个月大了");
    }
}

10.5 匿名内部类

本质上是没有名字的局部内部类，定义在方法中、代码块中等。

作用：方便创建子类对象，最终目的是为了简化代码编写。

语法格式：

new 类|抽象类名|接口名(){
    方法;
};
Employee a = new Employee{
    public void work(){
        
    }
};
a.work();

基本使用：

package com.spark.innerclass;

/**
 * Animal class
 * description: 父类对象
 *
 * @author Administrator
 * @date 2023/2/26
 */
public abstract class Animal {

    public abstract void run();
}

package com.spark.innerclass;

/**
 * Tiger class
 * description: 子类对象
 *
 * @author Administrator
 * @date 2023/2/26
 */
public class Tiger extends Animal{
    @Override
    public void run() {
        System.out.println("老虎跑起来飞快~~~");
    }
}

package com.spark.innerclass;

/**
 * Test4 class
 * description:
 *
 * @author Administrator
 * @date 2023/2/26
 */
public class Test4 {
    public static void main(String[] args) {
        // 传统方式
        Animal animal = new Tiger();
        // 调用Tiger类的run方法
        animal.run();

        // 匿名内部类方式
        Animal animal2 = new Animal(){
            @Override
            public void run() {
                System.out.println("老虎跑的很快~~~");
            }
        };
        animal2.run();
    }
}

匿名内部类的特点：

匿名内部类是一个没有名字的内部类
匿名内部类写出来就会产生一个匿名内部类对象
匿名内部类的对象类型相当于当前new的类型的子类型

常见使用形式：

匿名内部类可以作为方法的实际参数进行传输

某个学校需要老师、学生、运动员一起参加游泳比赛

package com.spark.innerclass;

/**
 * Test5 class
 * description:
 *
 * @author Administrator
 * @date 2023/2/26
 */
// 定义接口
interface Swimming{
    // 游泳方法
    void swim();
}
public class Test5 {
     // 比赛方法
    public static void competition(Swimming swimming){
        System.out.println("比赛开始~~~~~~~~");
        swimming.swim();
        System.out.println("比赛结束~~~~~~~~");
    }
    public static void main(String[] args) {
        // 匿名内部类作为方法参数
        competition(new Swimming() {
            @Override
            public void swim() {
                System.out.println("学生游的很慢");
            }
        });
        competition(new Swimming() {
            @Override
            public void swim() {
                System.out.println("老师游的一般");
            }
        });
        competition(new Swimming() {
            @Override
            public void swim() {
                System.out.println("运动员游的很快");
            }
        });
    }
}

嗨饼干

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
04—面向对象进阶

static表示静态的意思，static可以修饰成员变量和成员方法。被static修饰的成员变量称为静态成员变量，属于类。该变量在内存中只会存储一份，可以被共享访问、修改。// 静态成员变量的使用类名.静态成员变量;//推荐方式对象名.静态成员变量;//不推荐被static修饰的方法称为静态成员方法，属于类。// 静态成员方法的使用类名.静态成员方法();//推荐方式对象名.静态成员方法();//不推荐什么是继承？Java中通过extends关键字，可以让一个类和另一个类建立起父子关系。
复制链接

扫一扫