天天看点
返回

一文带你了解Java中的静态关键字static和不可变关键字finalstatic 静态关键字final 关键字

static 静态关键字

java中，static是一个修饰符，用于修饰类的成员方法、类的成员变量，还可以修饰代码块。被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。

静态static关键字修饰成员变量

如果一个成员变量使用了static关键字,那么这个变量不再属于自己,而属于所在的类,多个对象共享一份数据。 
public class 学生类 {
    private int id; //学号
    private String name; //姓名
    private int age; //年龄
    static String room; //所在教室
    private static int idCounter=0; //学号计数器，每当new了一个新对象的时候，计数器++

    public 学生类() {
        this.id=++idCounter;
    }

    public 学生类(String name, int age) {
        this.name = name;
        this.age = age;
        this.id=++idCounter;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

接着下一个

public class 修饰成员变量 {
    public static void main(String[] args) {
        学生类 one = new 学生类("郭靖",19);
        one.room="101教室";
        System.out.println("姓名："+one.getName()+",年龄："+one.getAge()+"，教室是"+one.room+",学号是："+one.getId());
        学生类 two = new 学生类("黄蓉",17);
        //只对one里面的room进行赋值，two跟one用的同一个room，因为room所在教室通过了static关键字进行了修饰
        //所以多个对象共享同一个数据
        System.out.println("姓名："+two.getName()+",年龄："+two.getAge()+"，教室是"+two.room+",学号是："+two.getId());
    }
}

静态static关键字修饰成员方法

一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。

如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。

如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。

无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用。

静态变量:类名称.静态变量；

静态方法:类名称.静态方法()；

注意事项:

1.静态不能直接访问非静态。

原因:因为在内存当中是【先】有的静态内容，【后】有的非静态内容。“先人不知道后人，但是后人知道先人。"

2.静态方法当中不能用this。 原因，this代表当前对象，通过谁调用的方法，谁就是当前对象。"

public class 修饰成员方法 {
    int num; //成员变量
    static int num1;//静态变量

    //成员方法
    public void method(){
        System.out.println("这是一个普通的方法");
        System.out.println(num); //成员方法可以访问成员变量
        System.out.println(num1); //成员方法可以访问静态变量
    }

    //静态方法
    public static void methodStatic(){
        System.out.println("这是一个静态方法");
        System.out.println(num1);//静态方法可以访问静态变量
        //System.out.println(num);//静态方法不可以直接访问非静态【重点】
        //System.out.println(this); 静态方法中不能使用this关键字

    }
}

第二个
public class 修饰成员方法2 {
    public static void main(String[] args) {
        修饰成员方法 obj = new 修饰成员方法();
        //首先创建对象，才能使用没有static关键字的内容
        obj.method();

        //对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用
        obj.methodStatic(); //正确，不推荐，这种写法在编译之后也会被翻译成“类名称.静态方法名”
        修饰成员方法.methodStatic(); // 正确 推荐

        //对于本类当中的静态方法，可以省略类名称
        aa();
        修饰成员方法2.aa();//完全等效
    }
    public static void aa(){
        System.out.println("自己的方法");
    }
}

静态代码块

静念代码块的格式是: public class 类名称{ static{ //静态代码块的内容 } }

特点:当第一次用到本类时，静态代码块执行唯一的一次。

静态内容总是优先于非静态，所以静态代码块比构造方法先执行。

静态代码块的典型用途: 用来一次性地对静态成员变量进行赋值。

public class 静态代码块1 {
    static {
        System.out.println("静态代码块执行");
    }
    public 静态代码块1(){
        System.out.println("构造方法执行");
    }
}

第二个
public class 静态代码块2 {
    public static void main(String[] args) {
        静态代码块1 one = new 静态代码块1(); //第一次用到那个类时，静态代码块执行唯一一次
        静态代码块1 two = new 静态代码块1(); //静态代码块不执行了，只执行构造方法
    }
}

final 关键字

概述

final关键字代表最终、不可改变的。

常见四种用法:

1.可以用来修饰一个类

2.可以用来修饰一个方法

3.还可以用来修饰一个局部变量

4.还可以用来修饰一个成员变量

final关键字用于修饰类

概述：当final关键字用来修饰一个类的时候。

格式: public final class 类名称{ // ... }
含义:当前这个类不能有任何的子类。(太监类)

注意:一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写。

final类可以继承父类，可以重写覆盖父类方法；但他没有子类，那么他的方法不能被覆盖重写。

public final class MyClass {
	public void method(){
		System.out.println("方法执行!");
	}
}

final关键字用于修饰成员方法

当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。

格式:

修饰符 final 返回值类型 方法名称(参数列表){ //方法体 }

注意事项: 对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。 
public abstract class Fu {
	public final void method(){
		System.out.println("父类方法执行!");
	}

	public abstract /*final*/ void methodAbs() ; 
}



public class zi extends Fu {
	@Override
	public void methodAbs(){
	}
	
	//错误写法!不能覆盖重写父类当中final的方法
	// @Override 
	// public void method(){ 
	// System.outprintln("子类覆盖重写父类的方法!"); 
	//
}

final关键字用于修饰局部变量 

public static void main(String[] args){
	int num1=10;
	System.out.println(num1);//10 num1 =20;
	System.out.println(num1);// 20
	//一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。
	//“一次赋值，终生不变” 
	final int num2=200;
	System.out.println(num2);// 200
	num2=250;//错误写法!不能改变! 
	num2=200; // 错误写法!
	//正确写法!只要保证有唯一一次赋值即可 
	final int num3;
	num3=30;

	//对于基本类型来说，不可变说的是变量当中的数据不可改变
	//对于引用类型来说，不可变说的是变量当中的地址值不可改变 
	Student stu1 = new Student(name:"赵丽颖"); 
	System.outprintln(stu1);
	System.out.println(stu1.getName());//赵丽颖 
	stu1 =new Student(name:"霍建华"); 
	System.out.println(stu1);
	System.out.println(stu1.getName());//霍建华 
	final Student stu2 = new Student(name:"高圆圆");
	//错误写法!final的引用类型变量，其中的地址不可改变
	//stu2=newStudent("赵又廷”);
	System.out.println(stu2.getName());//高圆圆 
	stu2.setName("高圆圆圆圆圆圆");
	System.out.println(stu2.getName());//高圆圆圆圆圆圆
}

public class student {
	private String name;
	
	public Student(){
	}
	
	public Student(String name){
		this.name =name;
	}
	
	public String getName(){
		return name;
	}
	
	public void setName(Stringname){
		this.name =name;
	}
}

final关键字用于修饰成员变量 

public class Person {
	private final String name/*=鹿晗"*/;
	public Person(){
	name ="关晓彤";
	}
	public Person(String name){
		this.name =name;
	}
	public String getName(){
		return name;
	}

总结

静态代码块 成员方法 成员变量
上一篇: 未来不再遥不可及？一台能够不断升级的车了解下由于新能源车往往过一两年，就会在智能、功能这些方面有着突破，所以，老车主就会
下一篇: 设计模式入门到精通-设计模式简介

继续阅读