CRainyDay

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;
}
}

static

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

 评论



本博客所有文章除特别声明外,均采用[(CC BY-NC-SA 4.0)]许可协议。转载请注明出处!

本站使用 Material X 作为主题 , 总访问量为 次 。
Copyright © 2019 CRainyDay's Blog 版权所有