关键字

 以下是我们在写Java程序时需要注意的一些关键字，我们平时使用时需要多加注意。

1.访问限定符

   对变量、方法、类的区域进行限制的关键词。

   以下4种访问限定符按范围是：从大到小 

 

    1）.public

       区域:在同一个程序中可以在任意地方访问

 

    2）.protected

       区域:在同一个包中和同一个类，以及不同包中的子类中可以访问

 

    3）.默认不写

       区域:能在同一个包中和同一个类中被访问

 

    4）.private

       区域:只能在同一类中被访问

 

/**
 * 人类类
 * @author liuqingjian
 *
 */
public class person {
	public String name;
	protected String num;
	String add;
	private int age;
}
public class younger {

	public static void main(String[] args) {
		person a=new person();
		a.name="张三";
		a.num="123456";
		a.add="长沙";
		//a.age=15;//错误，The field person.age is not visible这个属性不可见。就是超出作用范围

	}
}

 

2.变量

   1）.类变量

       类是由拥有共同点的所有对象组成的的集合。类变量就是所有对象的共同属性。

       范围:能在同一个类中使用。

 

    2）.成员变量

       在类中定义的变量。就是描述类的外貌特征、身份信息等等。

       范围:能在同一个类中使用。

 

    3）.参数变量

      只存在于成员方法变量，利于对象之间的信息交互。

      范围:只能在同一个成员方法中使用。

 

    4）.局部变量

      只存在于某一块的变量，只有在这一块才可以使用，出了这一块不能使用。

      范围:在程序中的直观方式，在一对大括号之间定义，就只能在一对大括号之间使用。

 

   注意:在同一个类中，类变量和属性变量不能同名

          同一个方法中的参数变量和局部变量不能同名

          同一个类中的参数变量/局部变量是可以和类变量/属性变量同名的

 

3.this：用在构造方法和方法中

   1）.this.属性名：用来表示当前对象的属性

         this.方法名：用来表示对当前对象的方法的调用 

   2）.this(参数列表)：用来调用当前对象的构造方法

         用法：用在构造方法的第一行，表示当前类的某一个构造方法

         具体的哪一个构造方法取决于this后面的参数列表

/**
 * 人类类
 * @author liuqingjian
 *
 */
public class person {
	public String name;
	private String add;
	private int age;
	
	public person(){
		//this(参数列表)
		this("张三","长沙");
		//this.方法名
		this.set();
	}
	public person(String name,String add){
		//this.属性名
		this.name=name;
		this.add=add;
	}
	public void set(){
		System.out.println(this.name+"住在"+this.add);
	}
}

/**
 * 主类
 * @author liuqingjian
 *
 */
public class Demo {

	public static void main(String[] args) {
		person a = new person();
		person b = new person("李四","张家界");
	}
}

  

4.super：用在子类的构造方法中

   1）.super.属性名;或者 super.方法名();

        在子类中，用来表示当前类的父类对象，用来在子类中调用父类的方法

   2）.不写,默认为super();

   3）.super(参数列表);

        用法：在子类的构造方法中调用父类的某一个构造方法

       具体是哪一个由super后面的参数列表确定

 

/**
 * 人类类
 * @author liuqingjian
 *
 */
public class person {
	public String name;
	protected String add;
	private int age;
	
	public person(){
		//this(参数列表)
		this("张三","长沙");
		//this.方法名
		this.set();
	}
	public person(String name,String add){
		//this.属性名
		this.name=name;
		this.add=add;
	}
	public void set(){
		System.out.println(this.name+"住在"+this.add);
	}
}

/**
 * 年轻人类
 * @author Administrator
 *
 */
public class younger extends person {
	public younger(){
		//super(参数列表)
		super();
	}
	
	public void set(){
		//super.方法名()
		super.set();
		//super.属性名
		System.out.println(super.name+"现在正在"+super.add);
	}
}

/**
 * 主类
 * @author liuqingjian
 *
 */
public class Demo {

	public static void main(String[] args) {
		younger a = new younger();
	}
}

 

5.final：最终的，不可更改的

          可以用来修饰类、方法、变量

 

  用法：

         1、final修饰类          表示这个类不能被继承

         格式：public final class 类名{}

/**
 * 人类类
 * @author liuqingjian
 *
 */
public final class person {
	public String name;
	protected String add;
	private int age;
	
	public person(){
		//this(参数列表)
		this("张三","长沙");
		//this.方法名
		this.set();
	}
	public person(String name,String add){
		//this.属性名
		this.name=name;
		this.add=add;
	}
	public void set(){
		System.out.println(this.name+"住在"+this.add);
	}
}

 

 

错误： The type younger cannot subclass the final class person<!--StartFragment -->

           younger 类不能继承final class person类

 

         2、final修饰方法          表示这个方法不能被重写[覆盖]

         格式：访问限定符 final 返回值类型方法名(参数列表){}

 

/**
*父类中
*/
public final void set(){
		System.out.println(this.name+"住在"+this.add);
	}
/**
*子类中
*/
public void set(){
   
      //super.方法名()

        super.set();       

      //super.属性名
        System.out.println(super.name+"现在正在"+super.add);
}

 错误：Cannot override the final method from person

           来自person的方法不能被重写

 

         3、final修饰变量          表示这个变量不能被修改，仅且必须且只能赋值一次

         格式:

                1.修饰类、属性、局部变量：访问限定符    final     变量类型    变量名;

                2.修饰参数变量：final   变量类型    变量名;

public final String name;

public person(final String name,String add){
		//this.属性名
		this.name=name;
		this.add=add;
	}

 

 

6.static：静态的

            可以用来修饰类 属性 方法

           1、static属性类属性：当前类所有的对象共用的同一个属性变量

                类属性格式：访问限定符   static    变量类型   变量名;

               可以通过对象或者类名调用

           2、static 方法是类方法：当前类所有的对象共用的同一个方法

                类方法格式：访问限定符  static   返回值类型   方法名(参数列表){}

                注意：类方法中不能使用this和super

public static void set(){
		//super.方法名()
		super.set();
		//super.属性名
		System.out.println(super.name+"现在正在"+super.add);
	}

 

 

                          类方法是调用父类还是子类重写的，只和类名有关

                         成员方法：成员方法是调用父类还是子类重写的，只和对象本身有关 

  

/**
 * 人类类
 * @author liuqingjian
 *
 */
public class person {
	public final String name;
	protected String add;
	private int age;
	
	public person(){
		//this(参数列表)
		this("张三","长沙");
		//this.方法名
		this.set();
	}
	public person(final String name,String add){
		//this.属性名
		this.name=name;
		this.add=add;
	}
	public void set(){
		System.out.println(this.name+"住在"+this.add);
	}
}

/**
 * 年轻人类
 * @author Administrator
 *
 */
public class younger extends person {
	public younger(){
		//super(参数列表)
		super();
	}
	
	public void set(){
		//super.方法名()
		super.set();
		//super.属性名
		System.out.println(super.name+"现在正在"+super.add);
	}
}

/**
 * 主类
 * @author liuqingjian
 *
 */
public class Demo {
	public static void main(String[] args) {
		younger MN = new younger();

		person bb = new younger();
		bb.set();
	}
}

 输出：

 

                         static方法中不能直接调用非静态的属性和方法

                         static的属性和方法是不需要对象调用的

                        类名.方法名();

          3、static代码块[]

               执行顺序:

               1、静态代码块/静态变量【两者按照前后顺序】

                    静态代码块、静态变量作用：初始化数据

               2、主函数

               3、创建对象时,非静态代码块/非静态变量【两者按照前后顺序】

                   非静态代码块、非静态变量作用：初始化对象的数据

 

/**
 * 主类
 * 
 * @author liuqingjian
 *
 */
public class Demo {
	//非静态变量
	public A a = new A();
	//静态变量
	public static B b = new B();
	//
	{

	}
	//静态代码块
	static{
		System.out.println("DDDDD");
	}
	//非静态代码块
	public static void set(int n) {
		System.out.println("n=" + n);
	}

	public static void main(String[] args) {
		Demo MN = new Demo();
		MN.set(65);
	}
}

 

结果: