Java程序设计--面向对象进阶(上)（七）

会思想的苇草i2024-03-27 19:03

面向对象进阶（上）

  • 1、静态关键字--static
    • [1.1 static修饰成员变量的基本用法](#1.1 static修饰成员变量的基本用法 "#11_static_4")
    • [1.2 static修饰成员变量的内存原理](#1.2 static修饰成员变量的内存原理 "#12_static_62")
    • [1.3 static修饰成员方法的基本用法](#1.3 static修饰成员方法的基本用法 "#13_static_65")
    • [1.4 static修饰成员方法的内存原理](#1.4 static修饰成员方法的内存原理 "#14_static_113")
    • [1.5 static实际应用案例](#1.5 static实际应用案例 "#15_static_117")
    • [1.6 static的注意事项](#1.6 static的注意事项 "#16_static_195")
  • 2、static应用--代码块
  • 3、static应用--单例设计模式
    • [3.1 设计模式](#3.1 设计模式 "#31__276")
    • [3.2 饿汉单例设计模式](#3.2 饿汉单例设计模式 "#32__286")
    • [3.3 懒汉单例设计模式](#3.3 懒汉单例设计模式 "#33__334")
  • 4、面向对象特征--继承
    • [4.1 继承](#4.1 继承 "#41__386")
    • [4.2 继承的原理](#4.2 继承的原理 "#42__462")
    • [4.3 继承的特点](#4.3 继承的特点 "#43__467")
    • [4.4 继承后的访问](#4.4 继承后的访问 "#44__483")
    • [4.5 继承后的方法重写](#4.5 继承后的方法重写 "#45__521")
    • [4.6 继承后的子类构造器](#4.6 继承后的子类构造器 "#46__590")
    • [4.7 this、super使用总结](#4.7 this、super使用总结 "#47_thissuper_607")

1、静态关键字--static

1.1 static修饰成员变量的基本用法

sctatic是静态的意思，可以修饰成员变量和成员方法。

static修饰成员变量表示该成员变量只在内存中只存储一份，可以被共享访问、修改。

静态成员变量(有static修饰，属于类，内存中加载一次)∶常表示如在线人数信息、等需要被共享的信息，可以被共享访问。

java 复制代码 
类名.静态成员变量(推荐)

对象.静态成员变量(不推荐)

实例成员变量（无static修饰，存在于每个对象中)︰常表示姓名name、年龄age、等属于每个对象的信息。

java 复制代码 
对象.实例成员变量
java 复制代码 
public class User {
    // 在线人数信息：静态成员变量
    public static int onLineNumber = 161;
    // 实例成员变量
    private String name;
    private int age;

    public static void main(String[] args) {
        // 1、类名.静态成员变量
        User.onLineNumber++;
        // 注意：同一个类中访问静态成员变量，类名可以省略不写
        System.out.println(onLineNumber);

        // 2、对象.实例成员变量
        // System.out.println(name);
        User u1 = new User();
        u1.name = "猪八戒";
        u1.age = 36;
        System.out.println(u1.name);
        System.out.println(u1.age);
        // 对象.静态成员变量(不推荐这样访问)
        u1.onLineNumber++;

        User u2 = new User();
        u2.name = "孙悟空";
        u2.age = 38;
        System.out.println(u2.name);
        System.out.println(u2.age);
        // 对象.静态成员变量(不推荐这样访问)
        u2.onLineNumber++;

        System.out.println(onLineNumber);

    }
}

1.2 static修饰成员变量的内存原理

1.3 static修饰成员方法的基本用法

成员方法的分类:

  • 静态成员方法（有static修饰，属于类)，建议用类名访问，也可以用对象访问。
  • 实例成员方法（无static修饰，属于对象)，只能用对象触发访问。

使用场景

  • 表示对象自己的行为的，且方法中需要访问实例成员的，则该方法必须申明成实例方法。
  • 如果该方法是以执行一个共用功能为目的，则可以申明成静态方法。
java 复制代码 
public class Student {
    private String name;
    private int age;

    /**
        实例方法：无static修饰，属于对象的，通常表示对象自己的行为，可以访问对象的成员变量
     */
    public void study(){
        System.out.println(name + "在好好学习，天天向上~~");
    }

    /**
        静态方法：有static修饰，属于类，可以被类和对象共享访问。
     */
    public static void getMax(int a, int b){
        System.out.println(a > b ? a : b);
    }

    public static void main(String[] args) {
        // 1、类名.静态方法
        Student.getMax(10, 100);
        // 注意：同一个类中访问静态成员 可以省略类名不写
        getMax(200, 20);

        // 2、对象.实例方法
        // study(); // 报错的
        Student s = new Student();
        s.name = "全蛋儿";
        s.study();

        // 3、对象.静态方法(不推荐)
        s.getMax(300,20);
    }
}

1.4 static修饰成员方法的内存原理

1.5 static实际应用案例

工具类中定义的都是一些静态方法，每个方法都是以完成一个共用的功能为目的。

工具类的好处

  • 调用方便
  • 提高了代码复用

工具类的定义注意

  • 建议将工具类的构造器进行私有，工具类无需创建对象。
  • 里面都是静态方法，直接用类名访问即可。
java 复制代码 
public class ArrayUtils {
    /**
       把它的构造器私有化
     */
    private ArrayUtils(){
    }

    /**
       静态方法，工具方法
     */
    public static String toString(int[] arr){
        if(arr != null ){
            String result = "[";
            for (int i = 0; i < arr.length; i++) {
                result += (i == arr.length - 1 ? arr[i] : arr[i] + ", ");
            }
            result += "]";
            return result;
        }else {
            return null;
        }
    }

    /**
     静态方法，工具方法
     */
    public static double getAverage(int[] arr){
        // 总和  最大值 最小值
        int max = arr[0];
        int min = arr[0];
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] > max){
                max = arr[i];
            }
            if(arr[i] < min){
                min = arr[i];
            }
            sum += arr[i];
        }
        return (sum - max - min)*1.0 / (arr.length - 2);
    }
}
java 复制代码 
public class Test {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30};
        System.out.println(arr);
        System.out.println(ArrayUtils.toString(arr));
        System.out.println(ArrayUtils.getAverage(arr));

        int[] arr1 = null;
        System.out.println(ArrayUtils.toString(arr1));
        int[] arr2 = {};
        System.out.println(ArrayUtils.toString(arr2));

    }
}

1.6 static的注意事项

  • 静态方法只能访问静态的成员，不可以直接访问实例成员。
  • 实例方法可以访问静态的成员，也可以访问实例成员。
  • 静态方法中是不可以出现this关键字的。

2、static应用--代码块

代码块概述

  • 代码块是类的5大成分之一(成员变量、构造器，方法，代码块，内部类)，定义在类中方法外。
  • 在Java类下，使用{}括起来的代码被称为代码块。

代码块分为

  • 静态代码块:
    • 格式: static{}
    • 特点:需要通过static关键字修饰，随着类的加载而加载，并且自动触发、只执行一次
    • 使用场景:在类加载的时候做一些静态数据初始化的操作，以便后续使用。
java 复制代码 
public class TestDemo1 {

    public static String schoolName;

    public static void main(String[] args) {
        // 目标：学习静态代码块的特点、基本作用
        System.out.println("=========main方法被执行输出===========");
        System.out.println(schoolName);
    }

    /**
     特点：与类一起加载，自动触发一次，优先执行
     作用：可以在程序加载时进行静态数据的初始化操作（准备内容）
     */
    static{
        System.out.println("==静态代码块被触发执行==");
        schoolName = "河工大";
    }
}
  • 构造代码块（了解，用的少):
    • 格式:{}
    • 特点:每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行
    • 使用场景:初始化实例资源。
java 复制代码 
public class TestDemo2 {

    private String name;

    /**
       属于对象的，与对象一起加载，自动触发执行。
     */
    {
        System.out.println("==构造代码块被触发执行一次==");
        name = "老王";
    }

    public TestDemo2(){
        System.out.println("==构造器被触发执行==");
    }

    public static void main(String[] args) {
        // 目标：学习构造代码块的特点、基本作用
        TestDemo2 t = new TestDemo2();
        System.out.println(t.name);

        TestDemo2 t1 = new TestDemo2();
        System.out.println(t1.name);
    }

}

3、static应用--单例设计模式

3.1 设计模式

设计模式(Design pattern)：开发中经常遇到一些问题，一个问题通常有n种解法的，但其中肯定有一种解法是最优的，这个最优的解法被人总结出来了，称之为设计模式。

设计模式有20多种，对应20多种软件开发中会遇到的问题，学设计模式主要是学2点:

  1. 这种模式用来解决什么问题。
  2. 遇到这种问题了，该模式是怎么写的，他是如何解决这个问题的。

单例模式

可以保证系统中，应用该模式的这个类永远只有一个实例，即一个类永远只能创建一个对象。例如任务管理器对象我们只需要一个就可以解决问题了，这样可以节省内存空间。

3.2 饿汉单例设计模式

在用类获取对象的时候，对象已经提前为你创建好了。

设计步骤

  • 定义一个类，把构造器私有。
  • 定义一个静态变量存储一个对象。
java 复制代码 
/**
    目标：学会使用饿汉单例模式设计单例类
 */
public class SingleInstance1 {
    /**
       static修饰的成员变量，静态成员变量，加载一次，只有一份
     */
    // public static int onLineNumber = 21;
    public static SingleInstance1 instance = new SingleInstance1();

    /**
        1、必须私有构造器：私有构造器对外不能被访问。
     */
    private SingleInstance1(){
    }


}
java 复制代码 
public class Test1 {
    public static void main(String[] args) {
//        SingleInstance1 s1 = new SingleInstance1();
//        SingleInstance1 s2 = new SingleInstance1();
//        SingleInstance1 s3 = new SingleInstance1();

        SingleInstance1 s1 = SingleInstance1.instance;
        SingleInstance1 s2 = SingleInstance1.instance;
        SingleInstance1 s3 = SingleInstance1.instance;
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s1 == s2);
    }
}

3.3 懒汉单例设计模式

在真正需要该对象的时候，才去创建一个对象（延迟加载对象）

设计步骤

  • 定义一个类，把构造器私有
  • 定义一个静态变量存储一个对象
  • 提供一个返回单例对象的方法
java 复制代码 
/**
    目标：设计懒汉单例
 */
public class SingleInstance2 {
    /**
       2、定义一个静态的成员变量用于存储一个对象，一开始不要初始化对象，因为人家是懒汉
     */
    private static SingleInstance2 instance;

    /**
       1、私有构造器啊
     */
    private SingleInstance2(){
    }

    /**
      3、提供一个方法暴露，真正调用这个方法的时候才创建一个单例对象
     */
    public static SingleInstance2 getInstance(){
        if(instance == null){
            // 第一次来拿对象，为他做一个对象
            instance = new SingleInstance2();
        }
        return instance;
    }
}
java 复制代码 
public class Test2 {
    public static void main(String[] args) {
        // 得到一个对象
        SingleInstance2 s1 = SingleInstance2.getInstance();
        SingleInstance2 s2 = SingleInstance2.getInstance();

        System.out.println(s1 == s2);
    }
}

4、面向对象特征--继承

4.1 继承

Java中提供一个关键字extends，用这个关键字，我们可以让一个类和另一个类建立起父子关系。

java 复制代码 
public class 子类 extends 父类 {
}

使用继承的好处：

当子类继承父类后，就可以直接使用父类公共的属性和方法了。因此，用好这个技术可以很好的我们提高代码的复用性

java 复制代码 
public class People {
    private String name;
    private int age;


    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;
    }
}
java 复制代码 
public class Student extends People{
    /**
       独有的行为
     */
    public void study(){
        System.out.println(getName() + "学生开始学习~~~~~");
    }
}
java 复制代码 
public class Teacher extends People{
    /**
       独有的行为
     */
    public void teach(){
        System.out.println("老师在快乐的教Java~~~~~");
    }

}
java 复制代码 
public class Test {
    public static void main(String[] args) {
        // 创建子类对象，看是否可以使用父类的属性和行为
        Student s = new Student();
        s.setName("杰哥"); // 父类的
        s.setAge(25);// 父类的
        System.out.println(s.getName());// 父类的
        System.out.println(s.getAge());// 父类的
        s.study();
    }
}

4.2 继承的原理

继承设计规范:

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

4.3 继承的特点

  • 子类可以继承父类的属性和行为，但是子类不能继承父类的构造器。
  • Java不支持多继承、但是支持多层继承。Java中所有的类都是Object类的子类。
  • Java是单继承模式:一个类只能继承一个直接父类，支持多层继承。
  • 子类不可以继承父类的构造器，子类有自己的构造器，父类构造器用于初始化父类对象。
  • 子类可以继承父类的私有成员，只是不能直接访问。
  • 子类不可以继承父类的静态成员，可以直接使用（共享并非继承）

4.4 继承后的访问

在子类方法中访问成员（成员变量、成员方法)满足:就近原则

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

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

java 复制代码 
super.父类成员变量/父类成员方法
java 复制代码 
public class ExtendsDemo {
    public static void main(String[] args) {
        Wolf w = new Wolf();
        System.out.println(w.name); // 子类的
        w.showName();
    }
}

class Animal{
    public String name = "父类动物";
}

class Wolf extends Animal{
    public String name = "子类动物";

    public void showName(){
        String name = "局部名称";
        System.out.println(name); // 局部的
        System.out.println(this.name); // 子类name
        System.out.println(super.name); // 父类name
    }
}

4.5 继承后的方法重写

什么是方法重写?

在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。

方法重写的应用场景

  • 当子类需要父类的功能，但父类的该功能不完全满足自己的需求时。
  • 子类可以重写父类中的方法。

Override重写注解

  • @Override是放在重写后的方法上，作为重写是否正确的校验注解。
  • 加上该注解后如果重写错误，编译阶段会出现错误提示。
  • 建议重写方法都加@Override注解，代码安全，优雅!

方法重写注意事项和要求

  • 重写方法的名称、形参列表必须与被重写方法的名称和参数列表一致。
  • 私有方法不能被重写。
  • 子类重写父类方法时，访问权限必须大于或者等于父类（暂时了解∶缺省<protected < public)
  • 子类不能重写父类的静态方法，如果重写会报错的。
java 复制代码 
public class Phone {
    public void call(){
        System.out.println("打电话开始~~~");
    }

    public void sendMessage(){
        System.out.println("发送短信开始~~~");
    }
}
java 复制代码 
public class NewPhone extends Phone{
    /**
      方法重写了
     */
    @Override
    public void call() {
        super.call();
        System.out.println("支持视频通话~~~");
    }

    /**
     方法重写了
     */
    @Override
    public void sendMessage() {
        super.sendMessage();
        System.out.println("支持发送图片和视频~~~");
    }
}
java 复制代码 
public class Test {
    public static void main(String[] args) {
        NewPhone huawei = new NewPhone();
        huawei.call();
        huawei.sendMessage();
    }
}

4.6 继承后的子类构造器

子类继承父类后构造器的特点:

  • 子类中所有的构造器默认都会先访问父类中无参的构造器，再执行自己。
  • 子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。
  • 子类初始化之前，一定要调用父类构造器先完成父类数据空间的初始化。

怎么调用父类构造器的

  • 子类构造器的第一行语句默认都是:super()，不写也存在。

super调用父类有参数构造器的作用:初始化继承自父类的数据。

如果父类中没有无参数构造器，只有有参构造器，会报错。因为子类默认是调用父类无参构造器的。

子类构造器中可以通过书写super(.....)，手动调用父类的有参数构造器

4.7 this、super使用总结

this:代表本类对象的引用; super:代表父类存储空间的标识。

关键字 访问成员变量 访问成员方法 访问构造方法
this this.成员变量 访问本类成员变量 this.成员方法(...) 访问本类成员方法 this(...) 访问本类构造器
super super.成员变量 访问父类成员变量 super.成员方法 访问父类成员方法 super(...) 访问父类构造器

this(...)和super(...)使用注意点:

  • 子类通过this (.） 去调用本类的其他构造器，本类其他构造器会通过super去手动调用父类的构造器，最终还是会调用父类构造器的。
  • this(...) super(...)都只能放在构造器的第一行，所以二者不能共存在同一个构造器中。
java 复制代码 
public class Student {
    private String name;
    private String schoolName;

    public Student() {
    }

    public Student(String name) {
        // 借用兄弟构造器！
        this(name, "河工大");
    }


    public Student(String name, String schoolName) {
        this.name = name;
        this.schoolName = schoolName;
    }

    public String getName() {
        return name;
    }

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

    public String getSchoolName() {
        return schoolName;
    }

    public void setSchoolName(String schoolName) {
        this.schoolName = schoolName;
    }
}
java 复制代码 
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("杰哥", "南德大学");
        System.out.println(s1.getName());
        System.out.println(s1.getSchoolName());


        Student s2 = new Student("阿伟");
        System.out.println(s2.getName());
        System.out.println(s2.getSchoolName());
    }
}
相关推荐
zwjapple1 小时前
docker-compose一键部署全栈项目。springboot后端，react前端
前端·spring boot·docker
像风一样自由20203 小时前
HTML与JavaScript：构建动态交互式Web页面的基石
前端·javascript·html
aiprtem4 小时前
基于Flutter的web登录设计
前端·flutter
浪裡遊4 小时前
React Hooks全面解析：从基础到高级的实用指南
开发语言·前端·javascript·react.js·node.js·ecmascript·php
why技术4 小时前
Stack Overflow，轰然倒下！
前端·人工智能·后端
GISer_Jing4 小时前
0704-0706上海，又聚上了
前端·新浪微博
止观止4 小时前
深入探索 pnpm：高效磁盘利用与灵活的包管理解决方案
前端·pnpm·前端工程化·包管理器
whale fall4 小时前
npm install安装的node_modules是什么
前端·npm·node.js
烛阴4 小时前
简单入门Python装饰器
前端·python
袁煦丞5 小时前
数据库设计神器DrawDB：cpolar内网穿透实验室第595个成功挑战
前端·程序员·远程工作
热门推荐
01Java学习第十五部分——MyBatis02集群聊天服务器---MySQL数据库的建立03Coze扣子平台完整体验和实践（附国内和国际版对比）04基于odoo17的设计模式详解---装饰模式05使用Ruby接入实时行情API教程06扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解07Everything文件检索工具 几秒检索几百G的文件08基于odoo17的设计模式详解---单例模式09DeepSeek各版本说明与优缺点分析10【无标题】