刻苦学习Java第十天【打卡贴】

最新推荐文章于 2024-11-02 15:22:06 发布

石油工人小李

最新推荐文章于 2024-11-02 15:22:06 发布

阅读量154

点赞数

文章标签：学习 java

本文链接：https://blog.csdn.net/m0_66376985/article/details/123672202

版权

课堂小小小项目练习：房屋出租系统

类变量

jdk7及之前，静态变量存在于方法区的静态域中

jdk8之后，静态变量存在于堆中

static变量是同一个类所有变量共享

staic变量在类加载时创建生成在.class的尾部，即使没有创建对象实例也可以访问

类变量也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量。

访问修饰符 static 数据类型变量名;(推荐)

static 访问修饰符数据类型变量名;

类名.类变量名（推荐）

对象名.类变量名

类变量的访问必须要遵守相关的访问权限

1. 需要让某个类的所有对象都共享一个变量时，就可以考虑类变量

2. 类变量是该类对象共享的，而实例变量是每个对象独享的

3. 加上static称为类变量/静态变量，否则为实例对象/普通变量/非静态变量

4. 类变量在类加载时就初始化了，即使没有创建对象，也可以使用类变量

5. 类变量的生命周期随着类的加载开始，随着类消亡而销毁

类方法

访问修饰符 static 数据返回类型方法名(){}(推荐)

static 访问修饰符数据返回类型方法名(){}

调用：类名.类方法名/对象名.类方法名

当方法中不涉及到任何和对象相关的成员，则可以将方法设计成静态方法，提高开发效率

将一些通用的方法设计成静态方法（打印一维数组、冒泡排序...）

1. 类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区，类方法中无this的参数，普通方法中隐含this的参数

2. 类方法可以通过类名调用，也可以通过对象名调用

3. 普通方法和对象有关，需要通过对象名调用，不能通过类名调用

4. 类方法中不能使用和对象有关的关键字，比如this和super，普通方法可以

5. 静态方法中只能访问静态变量或静态方法

6. 普通成员方法既可以访问非静态成员，也可以访问静态成员/方法

main方法

1. main方法在虚拟机中调用

2. java虚拟机需要调用main()方法，所以该方法的权限必须是public

3. java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static

4. 该方法接受String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数

在main()方法中，我们可以直接调用main方法所在类的静态方法和静态属性

但是不能直接访问该类的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员

代码块

代码块又称初始化块，属于类中的成员（即是类的一部分），类似于方法，将逻辑语句封装在方法体中，通过{}包围起来

但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用

[修饰符] {

代码

};

1. 修饰符可选，要写的话，只能写static

2. 有static 静态代码块没有static修饰的普通代码块/非静态代码块

3. 逻辑语句可以为任意逻辑语句（输入、输出、方法调用、循环、判断等）

4. ;可以写上，也可以省略

代码块的好处

1. 相当于另外一种形式的构造器（对构造器的补充机制），可以做初始化的操作

2. 如果多个构造器中都有重复的语句，可以抽取到初始代码块中，提高代码的复用

细节

1. static代码块也叫静态代码块，作用是对类进行初始化，随着类的加载而执行，而且只执行一次，普通代码块每创建一个对象就执行

2. 类什么时候被加载！！！

①创建对象实例（new）

②创建子类对象实例，父类也会被加载（父类先被加载）

③使用类的静态成员（静态属性，静态方法）->也要考虑父类

3. 普通的代码块，在创建对象实例时，会被隐式的调用，被创建一次调用一次，如果只是使用类的静态成员，普通代码块不会执行

4. 创建一个对象时，在一个类中的调用顺序是：

①调用静态代码块和静态属性初始化（二者优先级一样，按定义顺序）

②调用普通代码块和普通属性初始化（同上）

③调用构造方法

⑤构造器的最前面其实隐藏了super()和调用代码块，静态相关的代码块、属性初始化，在类加载时就执行完毕，因此优先于构造器和普通代码块执行

6. 创建一个子类对象时，他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下：

①父类的静态代码块和静态属性（优先级相同，按定义顺序执行）

②子类的静态代码块和静态属性（同上）

③父类的普通代码块和普通属性初始化（同上）

④父类的构造方法

⑤子类的普通代码块和普通属性初始化（同上）

⑥子类的构造方法

单例设计模式

所谓单例设计模式，就是采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只能提供一个取得其对象实例的方法

单例设计模式有两种方式：1. 饿汉式 2. 懒汉式

饿汉式：

1. 构造器私有化->防止直接new

2. 在类的内部创建对象

3. 向外暴露一个静态的公共方法 getInstance

4. 代码实现

package com.lemon.single_;

import org.w3c.dom.ls.LSOutput;

import javax.crypto.spec.PSource;

public class SingleTon01 {
    public static void main(String[] args) {
        GirlFriend instance = GirlFriend.getInstance();
        System.out.println(instance);
    }
}

//有一个类，GirlFriend
//只能有一个女朋友
class GirlFriend {
    private String name;
    //为了在静态方法中返回gf对象，需要将其修饰为static
    private static GirlFriend gf = new GirlFriend("小红红");

    //如何保证只能创建一个GirlFriend对象
    //步骤[单例模式-饿汉式]
    //1. 将构造器私有化
    //2. 在类的内部直接创建对象(该对象时static)
    //3. 提供一个公共的static方法，返回gf对象
    private GirlFriend(String name) {
        this.name = name;
    }

    public static GirlFriend getInstance() {
        return gf;
    }

    @Override
    public String toString() {
        return "GirlFriend{" +
                "name='" + name + '\'' +
                '}';
    }
}

懒汉式

package com.lemon.single_;

/**
 * 演示懒汉式的单例模式
 */
public class SingleTon02 {
    public static void main(String[] args) {
        Cat instance = Cat.getInstance();
        System.out.println(instance);
    }
}

//希望在程序运行过程中只能创建一个Cat对象
//使用单例模式
class Cat {
    private String name;
    private static Cat cat;
    //步骤
    //1. 仍然将构造器私有化
    //2. 定义一个static静态属性对象
    //3. 提供一个公共的public的static方法，可以返回一个Cat对象
    //4. 懒汉式，只有当用户使用getInstance方法时，才返回cat对象后
    // 后面再次调用时会返回上次创建的cat对象，从而保证单例

    private Cat(String name) {
        this.name = name;
    }

    public static Cat getInstance() {
        if (cat == null) {//如果还没有创建cat对象
            cat = new Cat("小可爱");
        }
        return cat;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                '}';
    }
}

二者不同之处：

1. 二者最主要的区别在于创建对象的时机不同：饿汉式在加载时就创建了对象实例，而懒汉式在使用时才创建

2. 饿汉式不存在线程安全问题，懒汉式存在线程安全问题（后面完善）

3. 饿汉式存在浪费资源的问题。因为如果程序员一个对象实例都没使用，那么饿汉式创建的对象就浪费了懒汉式是使用时才创建，就不存在这个问题

final关键字

final 可以修饰类、属性、方法和局部变量

程序员有如下需求，可以用final：

1. 当不希望类被继承，可以用final修饰

2. 当不希望父类的某个方法被子类覆盖/重写时，可以用final关键字修饰

访问修饰符 final 返回类型方法名

3. 当不希望某个类的属性值被修改，可以用final修饰

4. 当不希望某个局部变量被修改，可以用final修饰

final细节

1. final修饰的属性又叫常量，一般用XX_XX_XXX命名

2. final修饰的属性在定义时必须赋初值，并且以后不能修改，赋值可以在如下位置之一

①定义时：public final double TAX_RATE = 0.08

②在构造器中

③在代码块中

class AA{
    public final double TAX_RATE1 = 1;
    public final double TAX_RATE2;
    public final double TAX_RATE3;

    public AA() {
        TAX_RATE2 = 2;
    }
    {
        TAX_RATE3 = 3;
    }
}

3. 如果final修饰的属性时静态的，则初始化的位置只能是①定义时②在静态代码块中

4. final类可以实例化对象，但不能继承

5. 如果类不是final类，但含有final方法，则该方法虽然不能重写，但是可以被继承

6. 一般来说，如果一个类已经是final类，就没必要再将方法修饰成final方法

7. final不能修饰构造方法（即构造器）

8. final和static往往搭配使用，效率更高，不会导致类加载（底层编译器做了优化处理）

9. 包装类（Integer Double Float Boolean等都是final）String也是final类