一 : static关键字
static :静态的,可以用来修饰属性,方法,代码块(初始化块),内部类.被其修饰的属性有一个特点,在内存中存在于静态域,独一份.
类举例子
class SportMan{
//实例变量 随着对象的创建而被加载的
String name;
int age;
//类变量
static String nation;
public SportMan(String name, int age) {
super();
this.name = name;
this.age = age;
SportMan.nation = "中国人";
}
@Override
public String toString() {
return "SportMan [name=" + name + ", age=" + age + ", nation=" + nation + "]";
}
public void show() {
System.out.println("我是兽医");
}
public static void show1() {
System.out.println("w shi shou1 ");
info();
}
public static void info() {
System.out.println("我是静态傻狗");
}
}
调用举例
public class TestsportMan {
public static void main(String[] args) {
SportMan s1 = new SportMan("雪芙", 23);
SportMan s2 = new SportMan("百花", 23);
s1.nation = "china";
//对象调用
s1.show();
System.out.println(s1.toString());
System.out.println(s2);
System.out.println(SportMan.nation);
//类调用
SportMan.show1();
}
}
内存分部
内存分部
总结 :
static 修饰变量 - 类变量
- 由类创建的所有的对象,都公用这一个属性
- 当其中一个对象对此属性修改,会导致其他对象对此属性的一个调用发生变化.
- 类变量随着类的加载而加载,而且独一份.
- 静态的变量可以通过 类.类变量的形式来调用
- 类变量的加载要早于对象.
- 类变量存在于静态域中.
static 修饰方法 - 类方法
1.随着类的加载而加载,在内存中也是独一份.
2.可以直接通过 类.类方法 的方式调用
3.内部可以调用静态的属性或者静态的方法,而不能调用非静态的属性或方法.
而非静态的方法是可以调用静态的属性和方法,静态的方法内部 是不能有this 和 super 关键字.
(因为 类的加载要在对象之前, 可能会有空指针情况)
4.静态的结构 (static修饰的属性,代码块,内部类)的声明周期要早于非静态的结构,同时被回收也要晚于非静态结构.
二 : final关键字
final :最终的,可以修饰类,属性,方法,表示一种终结的最后的,好像一种竣工,一种永恒的结束.
- final :修饰类,这个类就不能被继承,如String 类,StringBuffer类,System类
报错
final class C{
}
class A extends C{
}
- final 修饰方法,不能被重写,Object类 getClass
报错
class C{
final public void tzShow() {
}
}
class A extends C{
public void tzShow() {
}
}
- final修饰属性,此属性就是一个常量,一旦初始化,不可再被赋值,习惯上用大写字母表示
1.被修饰常量不能使用默认初始化
2.可以显示的赋值,代码块,构造器
全局常量 : static final 修饰
class D {
//可以显示的赋值
final int I = 15;
final double PI;
final String name;
public void t1() {
System.out.println(I);
// 报错
I = 10;
}
//代码块赋值
{
PI = 3.14;
}
//构造器赋值
public D() {
name = "dd";
}
}
三 : 静态和非静态代码块.
- 非静态代码块
1.可以对类的属性(静态的和非静态的)进行初始化操作.同时也可以调用本类声明的方法
2.里面可以有输出语句
3.一类中可以有多个非静态的代码块,多个代码块之间按照顺序结构执行
4.每创建一个类的对象,非静态代码块就加载一次
5.非静态代码块的执行要早于构造器
class Order{
private int orderId = 1001;
private String orderName;
static String orderDesc;
//非静态的初始化块
{
orderId = 1002;
orderName = "雪芙";
System.out.println("trus youself");
orderDesc = "加油啊宇智波";
show1();
show2();
}
{
System.out.println("trus youself111");
}
public void show1() {
System.out.println("非静态方法");
}
public Order() {
super();
System.out.println("我是order空参构造器");
}
}
public static void show2() {
System.out.println("我是静态方法"+orderDesc);
}
- 静态代码块
1.里面可以有输出
2.随着类的加载而加载,而且只被加载一次
3.多个静态代码块之间按照顺序结构执行
4.静态代码块的执行要早于非静态代码的执行
class Order{
private int orderId = 1001;
private String orderName;
static String orderDesc;
//静态代码块
static {
System.out.println("DJB");
orderDesc = "你好啊";
//报错 : 静态的代码块只能执行静态的结构-类属性,类方法
// show1();
//不报错
// show2();
}
public Order() {
super();
System.out.println("我是order空参构造器");
}
public void show1() {
System.out.println("非静态方法");
}
public static void show2() {
System.out.println("我是静态方法"+orderDesc);
}
}
类属性赋值操作
1.默认的初始化或者代码块初始化
2.显示的初始化
3.构造器的初始化
4.通过方法对对象的相应属性进行修改
5.静态的代码块只能执行静态的结构,类属性,类方法.
四 : 单利设计模式
其目的是使整个项目中只能创建一个类相关的实例.
- 饿汉式
比较暴力的一种创建方式,直接new一个对象放入静态区达到目的
//只能创建singleton的单个实例
class Singleton{
//1.私有化构造器,使得在类的外部不能够调用次构造器
private Singleton() {
}
//2.在类的内部创建一个类的实例
private static Singleton instance = new Singleton();
//3.私有化此对象,通过公共的方法来调用
//4.此公共的方法,只能通过类来调用,因为设置为static的,同时类的实例也必须为static声明的
public static Singleton getInstance() {
return instance;
}
}
- 懒汉式
内存静态区不存在则创建,存在则不创建.
class Singleton1{
//1.私有化构造器,使得在类的外部不能够调用次构造器
private Singleton1() {
}
//2.在类的内部创建一个类的实例
private static Singleton1 instance = null;
//3 懒加载创建对象实例
public static Singleton1 getInstance() {
if (instance == null) {
instance = new Singleton1();
}
return instance;
}
}
测试是否相等
当然是相同的了,打印为 true
public class TestSingleton1 {
public static void main(String[] args) {
Singleton1 s1 = Singleton1.getInstance();
Singleton1 s2 = Singleton1.getInstance();
System.out.println(s1 == s2);
}
}