关键字总结

关键字总结

 

1.访问限定符 public/protected/默认/private

 

访问限定符在Java中被用来修饰属性、方法和构造方法。它的主要作用是给属性、方法和构造方法的访问设定了一个权限，只有满足这个条件，才能访问。在写程序的时候，我们的基本经验是属性基本上都声明成private的，方法

 

都声明成public的，类内部用的方法声明成protected的。 下面的表格，能够比较具体的表明各个访问限定符的作用范围。

 

 

工程 同一个包 同一个类 不同包中的子类

 

public √     √      √ √

 

protected     √      √ √

 

默认     √      √

 

private      √

 

 

 

在访问限定符的使用中，主要就是注意范围的大小问题，在声明的时候，父类中的各个范围应该大于等于子类中的范围。熟记上面的表格，访问限定符的一般使用就应该不成问题。

 

 

2.this/super

 

在Java中，this通常指当前的对象，而super则指父类中的一个对象。当你像引用当前对象的某种东西，比如当前对象的方法或属性，便可以利用this来完成这个任务。当然，this的另一个用途是调用当前对象的另一个构造函数。如果你想引用父

 

类中的某种属性或方法，那么则非super莫属。下面用代码进行示例。

 

 

代码示例：

this用法

 

 

public class A {

	private  int t;
	private String str;

	public A() {
		//在构造方法中调用构造方法，必须写在第一行
		
                this(0,"未知");//这种形式表示调用与当前具有相同参数的构造方法
		
                System.out.println("");
	}

	public A(int t) {
		this.t = t;//此处必须指明要引用的属性
	}

	public A(int t, String str) {
		this.t = t;
		this.str = str;
	}

	public void setT( int t) {
		this.t = t;
	}

	public  void test() {
		System.out.println("A的Test方法");
	}

}

 

 

super用法（调用属性和方法的用法与this基本相同，只不过变成调用父类中的方法）

 

 

public class B extends A{

	
	//子类的构造方法中一定要调用父类的某一个构造方法
	//默认是调用父类无参的构造方法

	//在创建子类对象的时候
	//首先是调用父类的构造方法，在调用子类的构造方法
	public B(){
		
                  super(10);//意义同this
	}
	
	
	public void test() {
		
		System.out.println("B重写的Test方法");
	}
	
	
	
	public void mt(){
		super.test();
	}
	


}

 

 

 

3.final

 

final的字面意思就是“最终的”，也就是终态的，不能被改变的意思。它能够用来修饰抽象类、非抽象类的成员属性和方法，它们分别有以下特点：1.final类不能被继承，没有子类。final类中的方法默认都是final类型的  2.final方法不能被子类的

 

方法覆盖，但是能被继承  3.final成员变量表示常量，只能被赋值一次，赋值后不能改变  4.final不能用来修饰构造方法  5.父类的private方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的  6.方法中的参数也可以用final，这

 

时这个参数只能被读取，但是我们无法改变参数的值。

 

 

代码示例：

 

1.final方法（把方法锁定，防止任何继承类修改它的意义和实现）

 

public class Test1 { 

public static void main(String[] args) { 
// TODO 自动生成方法存根 
} 

public void f1() { 
System.out.println("f1"); 
} 
//无法被子类覆盖的方法 
public final void f2() { 
System.out.println("f2"); 
} 

public void f3() { 
System.out.println("f3"); 
} 

private void f4() { 
System.out.println("f4"); 
} 
} 

public class Test2 extends Test1 { 

public void f1(){ 
System.out.println("Test1父类方法f1被覆盖!"); 
} 

public static void main(String[] args) { 
Test2 t=new Test2(); 
t.f1(); 
t.f2(); //调用从父类继承过来的final方法 
t.f3(); //调用从父类继承过来的方法 
//t.f4(); //调用失败，无法从父类继承获得 

} 
} 

 

2.final变量

 

public class Test3 { 

private final String S="final实例变量S"; 
private final int A=100; 
public final int B=90; 

public static final int C=80; 
private static final int D=70; 

public final int E; //final空白,必须在初始化对象的时候赋初值 

public Test3(int x){ 
E=x; 
} 

/** 
* @param args 
*/ 
public static void main(String[] args) { 
Test3 t=new Test3(2); 
//t.A=101; //出错,final变量的值一旦给定就无法改变 
//t.B=91; //出错,final变量的值一旦给定就无法改变 
//t.C=81; //出错,final变量的值一旦给定就无法改变 
//t.D=71; //出错,final变量的值一旦给定就无法改变 

 

 

3.final参数

 

 

public class Test4 { 

public static void main(String[] args) { 
new Test4().f1(2); 
} 

public void f1(final int i){ 
//i++; //i是final类型的,值不允许改变的. 
System.out.print(i); 
} 
} 

 

 

 

 

4.static

static是“静态”的意思，可以用来修饰属性和方法。当属性和方法被static修饰时，它将会独立于该类的任何对象。也就是说，它可以不需要一个实例化的对象去调用它，只要这个类被加载，我们就能使用它，这样的属性和方法可以在对象创建之

 

前被访问。用public修饰的成员变量和方法，当声明它的类的对象时，不生成static变量的副本，而是所有类的所有实例共享一个static变量。

 

代码示例：

 

//定义学生类,作为主类

public class Student  {

	public static String name ;

	public Student() {
		System.out.println("学生");
}

	public void setName(String name) {
		//this 指本内存区域中的同名对象
		this.name = name;
}

	public void study() {
		System.out.println(name+"在学习");
}

}

//子类 
public class UNStudent extends Student {

	public UNStudent() {
		
		System.out.println("大学生");
}
 
	//可以定义子类特有的方法
	
	public void cet4() {

		System.out.println(name+"可以考4级");
}

	//子类可以重写父类已经定义的方法

	public void study() {

		System.out.println(name+"在大学的教室里面学习");

}

}

	publi static void main(String args[]){

			 1.Student stu = new Student();

		stu.setName("AA");
		stu.study();		//执行结果：CC在学习


	2.UNStudent stu1 = new UNStudent();
		stu1.setName("BB");
		stu1.study();		//执行结果：CC在大学的教室里面学习
	

	
	3.Student stu2 = new UNStudent();
		stu2.setName("CC");
		stu2.study();		//执行结果：CC在大学的教室里面学习

//执行的结果只和姓名的最后一次改变有关

}
       

 

static代码块也叫静态的代码块，是类中独立于类成员的语句块，可以有多个，位置可以随意放，它不在任何方法体内，虚拟机在加在类是就会执行这些代码块。如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它

 

们，每个代码块只会被执行一次。这种使用方法有很大的用途。