Day01-static、单例、代码块、继承

static 静态关键字

static 是什么、修饰成员变量的用法：

static是静态的意思，可以修饰成员变量和成员方法
static修饰成员变量表示该成员变量只在内存中只存储一份，可以被共享访问、修改
成员变量分为两类：

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

public class User{
    //静态成员变量
    public static String onlineNumber = 161;
}
//类名.静态成员变量（推荐）
//对象.静态成员变量（不推荐）

实例成员变量（无static修饰，存在于每个对象中）：常表示姓名name、年龄age等属于每个对象的信息,且每个对象的该信息不同时

public class User{
    public static int onLineNumber = 161;
    //实例成员变量
    private String name;
    private int age;
}
//对象.实例成员变量
//同方法调用一样
//静态的都是类名.静态成员变量（方法）
//实例的都是推荐对象.实例成员变量（方法）

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

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

成员方法的分类：

静态成员方法（有static修饰，归属于类），建议用类名访问，也可以用对象访问。

/*访问格式：
    类名.静态成员方法
    对象.静态成员方法（不推荐)
    */

实例成员方法（无static修饰，归属于对象），只能用对象触发访问。

/*访问格式：
    对象.实例成员方法
    */

使用场景：

表示对象自己的行为的，且方法中需要访问实例成员的，则该方法必须申明成实例方法
如果该方法是以执行一个共用功能为目的，则可以申明成静态方法

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

public class Student {
    /**
     * 实例成员变量，无static修饰，属于对象
     */
    private String name;

    /**
     * 静态成员方法：有static修饰，归属于类，建议用类名访问，也可以用对象访问。
     */
    public static int getMax(int age1, int age2) {
        //如果该方法是以执行一个共用功能为目的，则可以申明成静态方法
        return age1 > age2 ? age1 : age2;
    }

    /**
     * 实例成员方法（无static修饰，归属于对象），只能用对象触发访问。
     */

    public void Study() {
        //表示对象自己的行为的，且方法中需要访问实例成员的，则该方法必须申明成实例方法
        System.out.println(name + "好好学习！");
    }

    public static void main(String[] args) {
        //1.类名.静态成员方法
        System.out.println(Student.getMax(2, 1));//类名.静态成员方法
        //注意，同一个类中，访问静态方法，类名可以省略不写
        System.out.println(getMax(3, 1));

        //2.对象.实例方法
        //study(); ->报错
        Student s = new Student();
        s.name = "cafune";//前面有一个静态成员变量private String name；
        s.Study();

        //3.对象.静态成员方法
        System.out.println(s.getMax(3, 0));
    }
}

static 的注意事项:

．静态方法只能访问静态的成员，不可以直接访问实例成员。实例成员是属于对象的

．实例方法可以访问静态的成员，也可以访问实例成员。

．静态方法中是不可以出现this关踺字的。

public class Warning {
    /**
     * 静态成员
     */
    public static int onLineNumber = 100;

    public static void test2() {
        System.out.println("-----");
    }

    /**
     * 实例成员
     */
    private String name;

    public void run() {
        System.out.println(name + "fast！");
        System.out.println(onLineNumber);
    }

    //3.静态方法中不可以出现this关键字
    public static void test3() {
        //System.out.println(this);->this只能代表当前对象
    }

    //2.实例方法可以访问静态成员，也可以访问实例成员
    public void go() {
        System.out.println(Warning.onLineNumber);
        System.out.println(onLineNumber);
        test2();
        System.out.println(name);
        run();
        System.out.println(this);
        System.out.println(this.name);
    }


    //1.静态方法只能访问静态的成员， 不可以直接访问实例成员。
    public static void test() {
        test2();
        Warning.test2();
        System.out.println(onLineNumber);
        System.out.println(Warning.onLineNumber);

        /*报错
        System.out.println(name);
        run();
         */
        Warning w = new Warning();
        w.name = "dd";
        System.out.println(w.name);
        w.run();

    }

    public static void main(String[] args) {
        //目标：理解static 访问相关的语法：面试笔试题，或者以后理解程序很重要的知识

    }
}

static 应用知识：工具类

工具类是什么

类中都是一些静态方法，每个方法都是以完成一个共用的功能为目的，这个类用来给系统开发人员共同使用的。

案例导学：

在企业的管理系统中，通常需要在一个系统的很多业务处使用验证码进行防刷新等安全控制。

使用工具类的好处

1.调用方便；

2.提高代码复用

为什么工具类中的方法不用实例方法做？

．实例方法需要创建对象调用。

．此时用对象只是为了调用方法，这样只会浪费内存。

工具类定义时的其他要求：

由于工具里面都是静态方法，直接用类名可访问，因此，工具类无需创建对象，建议工具类的构造器进行私有

工具类是什么，有什么好处？

．内部都是一些静态方法，每个方法完成一个功能

．一次编写，处处可用，提高代码的重用性。

工具类有什么要求？

．建议工具类的构造器私有化处理。

public class ArraysUtils {
    /**
     * 私有构造器
     */
    private ArraysUtils(){

    }
    /**
     * 工具方法，静态方法
     */
    public static String toString(int[] arr){
        //1.一些校验
        if (arr == null){
            return null;
        }

        //2.拼接内容并返回
        String result = "[";
        for (int i = 0; i < arr.length; i++) {
            result += (i == arr.length - 1 ? arr[i] : arr[i] + ",");

        }
        result += "]";
        return result;
    }
    /**
     * 工具方法，静态方法
     */
    public static double getAerage(int[] arr){
        double aerage = 0;
        double sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        aerage = sum / arr.length;
        return aerage;
    }

}

static 应用知识：代码块

代码块概述

．代码块是类的5 大成分之一（成员变量、构造器，方法/ 代码块，内部类） / 定义在类中方法外。

．在java 类下，使用{ } 括起来的代码被称为代码块。

代码块分为

静态代码块：

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

public class StaticDemo01 {

    public static String name;
    public static ArrayList<String> cards = new ArrayList<>();


    /**
     * 静态代码块：通过static 关键字修饰， 随着类的加载而加载， 并且自动触发、只执行一次
     * 作用：可以用于初始化静态资源
     */
    static {
        System.out.println("---静态代码块被触发执行了---");
        StaticDemo01.name = "cafune";//通过类名.静态成员变量 调用
        name = "dd";//在一个类中，静态成员变量可以直接调用
        cards.add("A");
        cards.add("k");
    }

    public static void main(String[] args) {
        System.out.println("---main方法执行了---");
        System.out.println(name);
        System.out.println(cards);
    }
}

构造代码块（了解，见的少）：->实例代码块无static修饰

格式：
特点：每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行
使用场景：初始化实例资源。

案例：斗地主游戏

static 应用知识：单例设计模式

设计模式、单例模式介绍、饿汉单例模式

什么是设计模式（Design pattern）

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

．设计模式有20 多种，对应20 多种软件开发中会遇到的问题。

．学设计模式主要是学2 点：

第一：这种模式用来解决什么问题。
第二：遇到这种问题了，该模式是怎么写的，他是如何解决这个问题的。

单例模式

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

单例的实现方式很多

饿汉单例模式。

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

设计步骤：1.定义一个类，把构造器私有 2.定义一个静态变量存储一个对象

/** a、定义一个单例类 */
public class SingleInstance{
    /** c.定义一个静态变量存储一个对象即可：属于类，与类一起加载一次*/
    public static SingeleInstance instance = new SingleInstance();
    
    /** b.单例必须私有构造器*/
    private SingleInstance(){
        System.out.println("创建了一个对象")
    }
}

实现饿汉单例模式步骤：

定义一个类，把构造器私有
定义一个静态变量存储一个对象

懒汉单例模式。

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

设计步骤：

定义一个类，把构造器私有
定义一个静态变量存储一个对象
提供一个返回单例对象的方法

//定义一个单例类
class SingleInstance{
    //定义一个静态变量存储一个对象即可：属于类，与类一起加载一次
    public static SingleInstance instance;///null
    
    //单例必须私有构造器
    private SingleInstance(){
        
    }
	//必须提供一个方法返回一个单例对象
    public static SingleInstance getInstance(){
        ...
            return ...;
    }
}

静态代码块的作用：

如果要在启动系统时堆静态资源进行初始化，则建议使用静态代码块完成数据的初始化操作。

面向对象三大特征之二：继承

什么是继承？

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

public class Student extends People { }

Student 称为子类（派生类） / Peop [ e 称为父类（基类或超类）。
作用：当子类继承父类后，就可以直接使用父类公共的属性和方法了

继承的好处

解决：继承（extends）关系，好处：提高代码复用性，减少代码冗余，增强类的功能扩展性

继承的格式：子类extends父类

继承后子类的特点：

子类继承父类，子类可以得到父类的属性和行为，子类可以使用
Java中子类更强大

继承设计规范：

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

why?

如果子类的独有属性、行为定义在父类中，会导致其他子类也会得到这些属性和行为，不符合面向对象逻辑

内存运行原理

继承的特点

子类可以继承父类的属性和行为，但是子类不能继承父类的构造器。
Java是单继承模式：一个类只能继承一个直接父类。
Java不支持多继承、但是支持多层继承。->子类A继承父类B，父类B可以继承父类C
Java中所有的类都是Object 类的子类。要么直接要么间接要么默认的继承了Object，Object是祖宗类

子类不能继承父类的构造器，子类有自己的构造器，父类构造器用于初始化父类对象。

子类可以继承父类私有成员,只是不能直接访问

子类可以直接使用父类的静态成员（共享），不算继承

继承后：成员变量、成员方法的访问特点

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

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

如果子父类中，出现了重名的成员会优先使用子类的，此时如果一定要在子类中使用父类的怎么办？

可以通过super 关键字，指定访问父类的成员
格式： super.父类成员变量/ 父类成员方法

继承后：方法重写

什么是方法重写：

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

方法重写的应用场景：

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

@Override重写注解：

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

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

重写方法的名称、形参列表必须与被重写方法的名称和参数列表一致。
私有方法不能被重写。
子类重写父类方法时，访问权限必须大于或者等于父类被重写的方法的权限（暂时了解：缺省< protected < public)
子类不能重写父类的静态方法，如果重写会报错

继承后：子类构造器的特点

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

子类中所有的构造器默认都会先访问父类中无参的构造器,再执行自己。

为什么？

子类在初始化的时候,有可能会使用到父类中的数据,如果父类没有完成初始化,子类将无法使用父类的数据。
子类初始化之前，一定要调用父类构造器先完成父类数据空间的初始化。

怎么调用父类构造器的？

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

class Dog extends Animal{
    public Dog() {
        super();//写不写都有，默认找父类的无参数构造器执行
        System.out.println("子类的无参数构造器被执行");
    }

    public Dog(String name){
        super();//写不写都有，默认找父类的无参数构造器执行
        System.out.println(name + "子类有参数构造器被执行");
    }
}

继承后：子类构造器访问父类有参构造器

super 调用父类有参数构造器的作用：

通过调用父类有参数构造器初始化继承自父类的数据。

如果父类中没有无参数构造器只有有参构造器，会出现什么现象呢？

会报错。因为子类默认是调用父类无参构造器的。

如何解决？

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

this和super使用总结

this和super详情

this：代表本类对象的引用；super：代表父类存储空间的标识

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

public class Test {
    //理解this（...)的作用：本类构造器中访问本类兄弟构造器
    public static void main(String[] args){
        Student s = new Student("dd", "normal school");
        System.out.println(s.getName());
        System.out.println(s.getSchoolName());

        //如果学生不填写学校，默认这个对象的学校是黑马
        Student s1 = new Student("cafune");
        System.out.println(s1.getName());
        System.out.println(s1.getSchoolName());
    }
}
class Student{
    private String name;
    private String schoolName;
    public Student() {
    }
    /**
     * 如果学生不填写学校，默认这个学校是黑马，
     * 调用了 public Student(String name, String schoolName)构造器
     * @param name
     */
    public Student(String name){
        //借用本类兄弟构造器
        //默认的super();没有了
        //super()必须先初始化父类，再初始化自己
        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;
    }
}

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

子类通过this(...)去调用本类的其他构造器，本类其他构造器会通过super去手动调用父类的构造器，最终还是会调用父类构造器的。
this(...)和super(...)都只能放在构造器的第一行，所以二者不能共存在同一个构造器中

posted on 2022-04-24 21:37 Cafune-Ding 阅读(35) 评论(0) 收藏举报

Day01-static、单例、代码块、继承

Day01-static、单例、代码块、继承

static 静态关键字

static 是什么、修饰成员变量的用法：

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

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

成员变量分为两类：

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

实例成员变量（无static修饰，存在于每个对象中）：常表示姓名name、年龄age等属于每个对象的信息,且每个对象的该信息不同时

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

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

成员方法的分类：

静态成员方法（有static修饰，归属于类），建议用类名访问，也可以用对象访问。

实例成员方法（无static修饰，归属于对象），只能用对象触发访问。

使用场景：

表示对象自己的行为的，且方法中需要访问实例成员的，则该方法必须申明成实例方法

如果该方法是以执行一个共用功能为目的，则可以申明成静态方法

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

static 的注意事项:

． 静态方法只能访问静态的成员， 不可以直接访问实例成员。实例成员是属于对象的

． 实例方法可以访问静态的成员， 也可以访问实例成员。

． 静态方法中是不可以出现this关踺字的。

static 应用知识： 工具类

工具类是什么

类中都是一些静态方法， 每个方法都是以完成一个共用的功能为目的， 这个类用来给系统开发人员共同使用的。

案例导学：

在企业的管理系统中， 通常需要在一个系统的很多业务处使用验证码进行防刷新等安全控制。

使用工具类的好处

1.调用方便；

2.提高代码复用

为什么工具类中的方法不用实例方法做？

． 实例方法需要创建对象调用。

． 此时用对象只是为了调用方法， 这样只会浪费内存。

工具类定义时的其他要求：

由于工具里面都是静态方法，直接用类名可访问，因此，工具类无需创建对象，建议工具类的构造器进行私有

工具类是什么， 有什么好处？

． 内部都是一些静态方法， 每个方法完成一个功能

． 一次编写， 处处可用， 提高代码的重用性。

工具类有什么要求？

． 建议工具类的构造器私有化处理。

static 应用知识： 代码块

代码块概述

． 代码块是类的5 大成分之一（ 成员变量、构造器， 方法/ 代码块， 内部类） / 定义在类中方法外。

． 在java 类下， 使用{ } 括起来的代码被称为代码块。

代码块分为

静态代码块：

格式： static{}

特点： 需要通过static 关键字修饰， 随着类的加载而加载， 并且自动触发、只执行一次

使用场景： 在类加载的时候做一些静态数据初始化的操作， 以便后续使用。

构造代码块（ 了解， 见的少） ：->实例代码块 无static修饰

格式：

特点： 每次创建对象， 调用构造器执行时， 都会执行该代码块中的代码， 并且在构造器执行前执行

使用场景： 初始化实例资源。

案例：斗地主游戏

static 应用知识： 单例设计模式

设计模式、单例模式介绍、饿汉单例模式

什么是设计模式（Design pattern）

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

． 设计模式有20 多种， 对应20 多种软件开发中会遇到的问题。

． 学设计模式主要是学2 点：

第一： 这种模式用来解决什么问题。

第二： 遇到这种问题了， 该模式是怎么写的， 他是如何解决这个问题的。

单例模式

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

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

单例的实现方式很多

饿汉单例模式。

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

设计步骤：1.定义一个类，把构造器私有 2.定义一个静态变量存储一个对象

实现饿汉单例模式步骤：

定义一个类，把构造器私有

定义一个静态变量存储一个对象

懒汉单例模式。

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

设计步骤：

定义一个类，把构造器私有

定义一个静态变量存储一个对象

提供一个返回单例对象的方法

静态代码块的作用：

如果要在启动系统时堆静态资源进行初始化，则建议使用静态代码块完成数据的初始化操作。

．静态方法只能访问静态的成员，不可以直接访问实例成员。实例成员是属于对象的

．实例方法可以访问静态的成员，也可以访问实例成员。

．静态方法中是不可以出现this关踺字的。

static 应用知识：工具类

类中都是一些静态方法，每个方法都是以完成一个共用的功能为目的，这个类用来给系统开发人员共同使用的。

在企业的管理系统中，通常需要在一个系统的很多业务处使用验证码进行防刷新等安全控制。

．实例方法需要创建对象调用。

．此时用对象只是为了调用方法，这样只会浪费内存。

工具类是什么，有什么好处？

．内部都是一些静态方法，每个方法完成一个功能

．一次编写，处处可用，提高代码的重用性。

．建议工具类的构造器私有化处理。

static 应用知识：代码块

．代码块是类的5 大成分之一（成员变量、构造器，方法/ 代码块，内部类） / 定义在类中方法外。

．在java 类下，使用{ } 括起来的代码被称为代码块。

特点：需要通过static 关键字修饰，随着类的加载而加载，并且自动触发、只执行一次

使用场景：在类加载的时候做一些静态数据初始化的操作，以便后续使用。

构造代码块（了解，见的少）：->实例代码块无static修饰

特点：每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行

使用场景：初始化实例资源。

static 应用知识：单例设计模式

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

．设计模式有20 多种，对应20 多种软件开发中会遇到的问题。

．学设计模式主要是学2 点：

第一：这种模式用来解决什么问题。

第二：遇到这种问题了，该模式是怎么写的，他是如何解决这个问题的。

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

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

面向对象三大特征之二：继承

Student 称为子类（派生类） / Peop [ e 称为父类（基类或超类）。

作用：当子类继承父类后，就可以直接使用父类公共的属性和方法了

子类可以继承父类的属性和行为，但是子类不能继承父类的构造器。

Java是单继承模式：一个类只能继承一个直接父类。

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

如果子父类中，出现了重名的成员会优先使用子类的，此时如果一定要在子类中使用父类的怎么办？

可以通过super 关键字，指定访问父类的成员

加上该注解后如果重写错误，编译阶段会出现错误提示。

建议重写方法都加@Override 注解，代码安全/ 优雅！

子类重写父类方法时，访问权限必须大于或者等于父类被重写的方法的权限（暂时了解：缺省< protected < public)

如果父类中没有无参数构造器只有有参构造器，会出现什么现象呢？