第六章、static关键字的使用，main(）方法的使用、代码块的使用、final关键字的使用

系列文章目录

第六章、static关键字的使用，main(）方法的使用、代码块的使用、final关键字的使用

---

---

一、java.long.Object类

1.Object类是所有java类的根父类

2.如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类

3.Object类中的功能（属性、方法）就具有通用性
属性：无
方法：equals() toString()…

4.Object 类只声明了一个空参的构造器

二、自动装箱、自动拆箱

1.自动装箱

自动装箱：基本数据类型–>包装类

int num2=10;
Integer in1=num2;//自动装箱

2.自动拆箱

自动拆箱–>包装类–>基本数据类型

System.out.println(in1.toString());

3.String类型–>基本数据类型、包装类:

调用包装类的parseXxx(String s)

public void test5(){
        String str1="123";
        int num2=Integer.parseInt(str1);
        System.out.println(num2+1);
    }

4.基本数据类型、包装类–>String类型：

调用String重载的valueOf(Xxx xxx)

    public void test6(){
        int num1=10;
        String str1=num1+"";

        float f1=12.3f;
        String str2=String.valueOf(f1);
    }

三、Object类中toSting的应用

1.当我们输出一个对象的引用时，实际上就是调用当前对象的toString()

2.Object类中tostring的定义：
public String toString() {
return getClass().getName() + “@” + Integer.toHexString(hashCode());
}

3.像String、date、File、包装类等都重写了Object类中的toString()方法

4.自定义类也可以重写toString()方法，当调用此方法时，返回对象的“实体内容“

四、static关键字的使用

1.static ：静态的

2.static可以用来修饰：属性、方法、代码块、内部类（不能用来修饰构造器）

3.使用static来修饰属性:静态变量

3.1属性：按是否使用static修饰，又分为：静态属性vs非静态属性（实例变量）
== 实例变量==：我们创建了类的多个变量，每个对象都独立的拥有一套类中的非静态属性
当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改
== 静态变量==：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用时是修改过的
3.2 static 修饰属性的其他说明：

1）静态变量随着类的加载而加载。可以通过”类.静态变量“的方式进行调用
2）静态变量的加载要早于对象的创建
3）由于类只会加载一次，则静态变量在内存中只会存在一份：存在方法区的静态域中
4） 类变量 实例变量
类 yes no
对象 yes yes

3.3静态属性举例：System.out; Math.PI

4.使用static来修饰方法:静态方法

1）随着类的加载而加载，可以通过”类.静态方法“的方式进行调用
2） 静态方法 非静态方法
类 yes no
对象 yes yes
3）静态方法中，只能调用静态的方法或属性
非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

5.static注意点：

5.1在静态的方法内，不能使用this关键字、super关键字
5.2 关于静态属性和静态方法的使用，都从高生命周期的角度去理解

6. 开发中，如何确定一个属性是否声明为static？
   属性可以被多个对象所共享的，不会随着对象的不同而不同的
   开发中，如何确定一个方法是否声明为static？
   操作静态属性的方法，通常设置为static的
   工具类中的方法，习惯上声明为static的。比如：Math、Arrays、Collections

五、单例设计模式

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

2.如何实现？
饿汉式 vs 懒汉式

3.区分饿汉式和懒汉式

饿汉式：
好处：饿汉式是线程安全的
坏处：对象的加载时间过长

//饿汉式
class Bank{
    //1.私有化类的构造器
    private Bank(){

    }
    //2.内部创建类的对象
    //4.要求此对象也必须声明为静态的
    private static Bank instance=new Bank();

    //3.提供公共的方法，返回类的对象


    public static Bank getInstance() {
        return instance;
    }
}

懒汉式：
好处：延迟对象的创建
坏处：线程不安全–>到多线程内容时，再修改

class Order{
    //1.私有化类的构造器
    private Order(){

    }
    //2.声明当前类的对象，没有初始化
    //4.此对象必须声明为static的
    private static Order instance=null;

    //3.声明public,static 的返回当前类对象的方法
    public static Order getInstance() {
        if (instance==null){
            instance=new Order();
        }
        return instance;
    }
}

六、main()方法的使用说明

1.main()方法作为程序的入口
2.main()方法是一个普通的静态方法
3.main()方法可以作为我们与控制台交互的方式。（之前，使用Scanner）

七、类的成员之四，代码块（或初始化块）

1.代码块的作用

用来初始化类、对象

2.代码块如果有修饰的话，只能使用static

3.分类：

静态代码块 非静态代码块

4.静态代码块

内部可以有输出语句
随着类的加载而执行，而且只执行一次

作用：

初始化类的信息

如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
静态代码块的执行优于非静态代码块的执行
静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构

5.非静态代码块

内部可以有输出语句
随着对象的创建而执行
每创建一个对象，就执行一次非静态代码块

作用：

可以在创建对象时，对对象的属性进行初始化
非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法

对属性可以赋值的位置：

1）默认初始化
2）显示初始化
3）构造器中初始化
4）有了对象以后，可以通过”对象.属性“或”对象.方法“的方式，进行赋值
5）在代码块中赋值

顺序：1–>2/5–>3–>4

八、final: 最终的

1.final可以用来修饰结构，类、方法、变量

2.final用来修饰一个类：此类不能被其他类所继承
比如：String类、System类、StringBuffer类

3.final 用来修饰方法：表明此方法不可以被重写
比如：Object类中getClass()；

4.final用来修饰变量：此时的”变量“就称为是一个常量

4.1 final修饰属性：可以考虑赋值的位置有：显示初始化、代码块中初始化、构造器中初始化、
4.2 final修饰局部变量，
尤其是使用final修饰形参时，表明此形参时一个常量。当我们调用此方法时，给常量形参赋一个实参，一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值
static final 用来修饰属性：全局常量