滚滚向前滚

导航

 

目录

1. 修饰符(访问控制)

访问控制

default: 是不写访问控制符

2. static关键字

2.1 用法

修饰属性、方法等

2.2 static方法

2.2.1 static方法特点

  1. 被声明为static的成员在内存中只保存了一份,存储在方法区中
  2. 被声明为static的成员会在类加载的时候加载进内存,而其他非静态成员是在创建对象的时候才会去分配内存
  3. 被static修饰的成员可以直接通过类名来访问,因为它们不依赖于对象。类名.方法类名.属性
  4. 对于一些不常改变的对象可以声明成静态的成员,这样就可以共享这一份资源,而且不会浪费内存
  5. 一些工具方法适合声明成静态的,因为可以直接拿来调用,更方便,但是不是所有的方法都适合声明成静态的,因为静态成员的生命周期长
  6. 对于静态变量,可以通过类名和引用来访问,建议通过类名来访问,不建议通过引用来访问
  7. 静态方法,没有隐式this,所以在静态方法中无法方位实例中的变量,方法。实例方法传入了隐式this,可以访问实例的属性和变量
  8. 静态方法应用场景: 操作与参数有关于对象无关(对对象属性没有做操作)时,定义为静态方法,例如Arrays.sort()。也就是说static方法的作用在于提供一些"工具方法"和"工厂方法"

2.2.2 案例

package src.basic.language;

import java.util.HashSet;
import java.util.Iterator;

/*
 * 这个类主要讲了Static关键字的用法
 * */

public class StaticKeywords {
	static int paramStatic = 0;
	int paramClass;
	public static void main(String [] args) {
		HashSet<String> set = new HashSet<String>();
		set.add("滚滚");
		set.add("加油");
		set.add("向前滚");
		
		// 对于static的方法、属性,可以不对类进行实例化,也可以调用
		StaticKeywords.traverSetWithList(set);
		StaticKeywords.traverseWithIterator(set);
		
		// 被声明为static的成员在内存中只保存了一份,如果在一个地方修改了这个静态变量的值,那么其他对象引用这个属性的值也会做对应的修改
		
		/*
		 * 这里例子省略,可以在备调用的类中声明一个static变量,之后在本类中实例化两个这个类型的变量来做观察
		 * */
	}
	
	public static void traverSetWithList(HashSet <String> set) {
		Object [] objs = set.toArray();
		for (Object obj : objs) {
			System.out.println(obj);
			set.add("再滚一次");
		}
		System.out.println();
		
	}
	
	public static void traverseWithIterator(HashSet <String> set) {
		// 在静态方法中,没有饮食的传入this,下面这条语句报错
		// this.paramClass = 1;
		
		// 静态属性通过类名.属性来确定
		StaticKeywords.paramStatic = 20;
		
		Iterator<String> itr = set.iterator();
		while(itr.hasNext()) {
			System.out.println(itr.next());
		}
		System.out.println();
	}
	
	public void testStatic() {
		this.paramClass = 20;
		StaticKeywords.paramStatic = 30;
	}
	
}

2.3 static块

        属于类的代码块,在类加载期间执行的代码块,只执行一次,可以用来在软件中加载静态资源

应用场景:

  1. 常常用于加载静态资源(图片、音频等)

2.3.1 案例

public class StaticKeywords {
	// 定义了一个静态块
	static {
		// 存储在方法区中,在类加载的时候执行的代码块
		System.out.println("静态块执行");
	}
	
	public static void main(String [] args) {
	}
}

// 执行结果
    静态块执行
    // main函数中没有任何代码,但是还是打印了静态块的语句,说明静态块在所有类实例化之前执行

3. final关键字

        final修饰的成员变量以及方法,都不能改变

  1. 修饰变量:变量不能被改变

    1. final修饰成员变量的两种方式:
      1. 声明的同时初始化
      2. 构造方法中初始化
    2. final修饰方法变量
      1. final修饰方法变量时,定义时可以不用赋值,只需要在使用前赋值即可,赋值之后不可修改
  2. 修饰方法:方法不能被重写

  3. 修饰类:类不能被继承,但是可以继承其他类

package src.basic.language;

public class KeyWordsFilnal {
	// 声明的同时修饰变量
	final int a = 5;
	
	// 声明的同时若没有初始化,要在构造函数中初始化
	final int b;
	public KeyWordsFilnal() {
		// TODO Auto-generated constructor stub
		// 构造方法中初始化
		b = 10;
	}
	
	void finalParam() {
		// 在类方法中,
		final int c;
		// 报错,使用之前要赋值
		// System.out.println(c);
		c = 6;
		// 报错
		// c = 7;
	}
	
	
	final void finalMethod() {}
	
	public  static void main(String [] args) {
		KeyWordsFilnal obj = new KeyWordsFilnal();
	}
}

// final的类可以继承其他的类
final class KeyWordsFinalChild extends KeyWordsFilnal{
	// 报错,final修饰的方法不能被重写
	// void finalMethod() {}
}

// 报错,final修饰的类不能继承
// class KeyWordsFinalGrandChild extends KeyWordsFinalChild{}

4. static final常量

        由static final修饰的成员变量成为常量,必须在声明的同时初始化,不可以被改变。由static final修饰的常量会在编译期间被替换。

4.1 规则和建议

  1. static public修饰的变量必须在声明时就赋值
  2. 访问static public修饰的常量和static关键字修饰的静态变量相同
  3. static public修饰的常量不可改变
  4. 建议常量所有字母都大写
  5. 在编译时会自动替换为具体的值,相当于C和C++里面的宏,执行效率较高

4.2 案例

package src.basic.language;

class KeywordsStaticFinal {
	public static void main(String [] args) {
		// 在编译时,程序还未执行前,KeywordsStaticFinal.PI被替换为3.14159
		// 这句话和System.out.println(3.14159)是一样的,由于少了一步转换的操作,使用常量程序运行效率更高
		System.out.println(KeywordsStaticFinal.PI);
	}
	
	public static final double PI= 3.14159;
	
	// 编译错误,static public修饰的变量必须在声明时就赋值
	// public staic final int NUM;
}
posted on 2018-05-12 10:19  滚滚向前滚  阅读(178)  评论(0编辑  收藏  举报