面向对象3.1

static关键字
main()方法
代码块
final

一.static

static: 静态的, 可以用来修饰属性、方法、*代码块(或初始化块)、*内部类

A.static修饰属性(类变量):

1. 由类创建的所有的对象，都共用这一个属性
2. 当其中一个对象对此属性进行修改, 会导致其他对象对此属性调用时也会更改. vs 实例变量(非static修饰的属性, 各个对象各自拥有一套副本)
3. 类变量随着类的加载而加载的, 而且独一份
4. 静态的变量可以直接通过“类.类变量”的形式来调用
5. 类变量的加载是要早于对象. 所以当有对象以后, 可以“对象.类变量”使用. 但是"类.实例变量"是不行的.
6. 类变量存在于内存的静态域中.

B.static修饰方法(类方法):

1. 随着类的加载而加载, 在内存中也是独一份
2. 可以直接通过“类.类方法”的方式调用
3. 方法内部可以调用静态的属性或静态的方法, 而不能调用非静态的属性或方法. 反之, 非静态的方法是可以调用静态的属性或静态的方法. 静态的方法内是不可以有this或super关键字的!

注意: 静态的结构(static的属性、方法、代码块、内部类)的生命周期要早于非静态的结构，同时被回收也要晚于非静态的结构

示例, 静态属性及内存状态:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

public Test{
    public static void main(String []args){
        SportsMan s1 = new SportsMan("金龙",23);
        SportsMan s2 = new SportsMan("银龙",20);
        s1.setName("花龙");
        s1.nation = "China";
    }
}
class SportsMan{
    private String name;
    private int age;
    public static String nation;
    SportsMan(){
    }
    SportsMan(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void setName(String name){
        this.name = name;
    }
}

C.单例模式

23种设计模式

• 单例模式(Singleton): 即类只能创建一个对象, Runtime类就是一个单例模式的应用
• 解决的问题: 如何只让设计的类只能创建一个对象
• 如何实现: 饿汉式 & 懒汉式

1. 私有化构造器
2. 在类内部创建类的对象, 同时设置为private的, 通过公共的方法来调用, 体现封装性
3. 一个public static的方法, 获得该(单例)对象
4. 要求该对象也为static的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

//饿汉式1
class Bank{
    //1.私有化构造器
    private Bank(){}
    //2.创建类的对象，同时设置为private的，通过公共的来调用，体现封装性
    //4.要求此对象也为static的
    private static Bank instance = new Bank();
    //3.此公共的方法，必须为static 
    public static Bank getInstance(){
        return instance;
    }
}
//饿汉式2
class Bank{
    //1.私有化构造器
    private Bank(){}
    //2.创建类的对象，同时设置为private的，通过公共的来调用，体现封装性
    //4.要求此对象也为static的
    private static Bank instance = null;
    static{
        instance  = new Bank();	
    }
    //3.此公共的方法，必须为static 
    public static Bank getInstance(){
        return instance;	
    }
}

//懒汉式
class Bank{
    private Bank(){}
    
    private static Bank instance = null;
    
    public static Bank getInstance(){
        if(instance == null){//可能存在线程安全问题的!
            instance = new Bank();	
        }	
        return instance;
    }
}

二.main()

1
2
3

public static void main(String[] args) throws Exception{
     //方法体     
}

1. main()是一个方法, 是主方法, 为程序的入口
2. 权限修饰符: public protected 缺省 private —面向对象的封装性
3. 对于方法来讲: static final abstract 可修饰
4. 方法的返回值: void / 具体的返回值类型(基本的数据类型 & 引用数据类型), 方法内部一定要有return
5. 方法名: 命名的规则: xxxYyyZzz. 给方法命名时, 要见名知意
6. 形参列表: 同一个方法名不同的形参列表的诸多个方法间构成重载. 形参 & 实参—方法的参数传递机制: 值传递
7. 抛出异常列表
8. 方法体: 方法定义的是一种功能, 具体的实现由方法体操作.

三.代码块

• 代码块: 是类的第4个成员, 由一对大括号括起来
• 作用: 用来初始化类的属性
• 分类: 只能用static来修饰.

A.静态代码块

1. 里面可以有输出语句
2. 随着类的加载而加载，而且只被加载一次
3. 多个静态代码块之间按照顺序结构执行
4. 静态代码块的执行要早于非静态代码块的执行.
5. 静态的代码块中只能执行静态的结构(类属性, 类方法)

B.非静态代码块

1. 可以对类的属性(静态的 & 非静态的)进行初始化操作, 同时也可以调用本类声明的方法(静态的 & 非静态的)
2. 里面可以有输出语句
3. 一个类中可以有多个非静态的代码块, 多个代码块之间按照顺序结构执行
4. 每创建一个类的对象, 非静态代码块就加载一次.
5. 非静态代码块的执行要早于构造器

关于属性赋值的操作:

①默认的初始化
②显式的初始化或代码块初始化(此处两个结构按照顺序执行)
③构造器中;
—————————以上是对象的属性初始化的过程—————————————
④通过方法对对象的相应属性进行修改

四.final

final:最终的, 可以用来修饰类、属性、方法

1. final修饰类: 这个类就不能被继承. 如: String类、StringBuffer类、System类
2. final修饰方法: 不能被重写. 如: Object类的getClass()
3. final修饰属性: 此属性就是一个常量, 一旦初始化后, 不可再被赋值. 习惯上, 常量用大写字符表示.
   此常量在哪里赋值: ①此常量不能使用默认初始化 ②可以显式的赋值、代码块、构造器.
   变量用static final修饰时: 全局常量. 比如: Math 类的PI