关键字总结

     

常用关键字的

1．  访问限定符有 public private  默认的 protected

用public  修饰的方法 在同一个工程中 都可以被调用  ，即在不同的包之间，不同的类之间，都可以被调用。

用 public  修饰的 属性 是公开 的

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    

 

用 protected  修饰的方法 在同一个包中  以及 子类中 可以被调用

采用 默认的  格式的 方法  只能在 同一个包中 被调用

用 private 修饰的方法 只能在 该方法所在的  的公共类中能被调用

  如下

 

2 。final  关键字 

 可以 修饰 属性 方法 类

 用final  修饰的  属性 不能够被修改

用final  修饰的类 不能 被继承，

 用final  修饰的 方法可以调用 但是 不能重写 （即 不能被修改）

相当于 一个非静态类中 一部分  不能被继承

  

3         this关键 字  和 super   

this  关键字 有两种 用法

     a）。表示当前类  的对象

     b）。在构造方法中  使用

super  是 调用 父类中的方法

子类中的 构造器 是 中 默认的是：

public  class  Student(){

 

}

public  class  USstudent  extends  Studnet(){

  pulbic   USstudent  (){

 

  super();

}

 

}

4 

        static 静态的

在 静态的 方法中不再存在 多态 现象。

package netjava.txc.key1;

public class Mykey1 {

	public static String name;
	
	public void setname(String name){
		this.name=name;
		
	}
	public  static void study(){
		
		System.out.println(name+"正在学习");
	}
	
}


package netjava.txc.key1;

public class Test1 {
	//程序入口
	public static void main(String args[]){
		//创建对象
		Mykey1 kk=new  Mykey1();
		 
		kk.setname("tianxichao");
		
		
		Mykey1 k1=new  Mykey1();
		k1.setname("guihaijiya");
		Mykey1.study();
		kk.study();
		
		k1.study();
      //静态的方法  不再存在多态现象  直接可以用  方法名去调用（也可以用对象去调用）
	}

}

 

 

 

1）。static  修饰 方法

在static 修饰的方法中  所用的 属性 一定是 static 修饰的

如下代码：

 

public class Mykey1 {

 public static String name;
 
 public void setname(String name){
  this.name=name;
  
 }
 public  static void study(){
  
  System.out.println(name+"正在学习");
 }
//如果 name的 不用static 修饰 System.out.println(name+"正在学习");
//就会出错  
}

 

  

  当创建 对象时 对于静态的方法 在内存中不 重新 创建 。 即所有的的对象  所调用的静态方法  均在 该类所使用的 内存中。

   2）用static  修饰的 属性 

    这些属性的值   不会随 对象创建后的改变而改变，与方法一样 只在内存中的一个地方而不会被“ 复制”。

如下例题：

package netjava.txc.key23;

public class A {
	public A(){
		System.out.println("A");
	}

}

package netjava.txc.key23;

public class B  extends   A {
	public B(){
		System.out.println("B");
	}

}



package netjava.txc.key23;

public class T {
	
	static A a=new A();
	B  b=new B();
	
	public static void main(String args[]){
		//创建T的对象
		T t=new T();
		
		t.change();
	}
	public void change(){
		 B b1 =new B();
	}
 }

 

  求他的结果？

结果是  A AB  首先在装载类的过程中  会先装在  static  static A a=new A();  构造器中的方法就会被调用，然后是主函数    创建 T的对象时   B  b=new B();  会被转载但不执行，  t调用 change方法时   B b1 =new B(); 会被执行   而B又继承了 A  所以 现调用 A中的 构造器   A  就会被输出  然后 再 输出B。

评论

1 楼 walkingman_c 2011-07-25  

  不错啊