常用关键字分析

1，关键字说明

1）在eclipse中，当你使用默认的字体和颜色时，黑色细体字是常用类名，常用方法名以及局部变量名，而粗体的红色字则代表的是Java中的关键字

2）Java中的关键字：与类相关的关键字：class、extends、implements、abstract、interface、package、import

                                     与方法相关的关键字：void、return

                                     与访问权限相关的关键字：public、protected、默认不写、private

                                     基本数据类型：short、int、long、float、double、byte、char、boolean

                                     和循环判断：if、else、switch、case、default、break、continue、while、do、for

                                     异常相关：try、catch、throw、throws、finally

                                     其他的关键字：this、super、final、instanceof、synchronized、static、enum

2，数据类型

1）数据类型分为两大类：基本数据类型与引用数据类型

2）基本数据类型分为8大类：short、int、long、float、double、byte、char、boolean，其字节长度分别为2、4、8、4、8、1、1、1

     注意：中文字符占两个字节、英文字符占1个字节

3）引用数据类型：也称为类类型（所有以类方式定义的类都称为引用数据类型），比如JFrmae、ArrayList、

     比如：

//定义了一个引用类型变量
JFrame jf;
//创造了一个JFrame对象，并将该对象的地址赋值给jf
jf = new JFrame;

4）引用类型与基本数据类型的区别：基本数据类型只能存储基本数据，没用属性与方法的调用

                                                              引用数据类型有属性与方法、并且可以执行复杂的操作

5）注意：8大基本数据类型都会对应一个引用类型:int对应integer、char对应character、其他6个的引用类型全部是基本数据类型的首字母大写

3，访问权限

1）访问权限的分类：public、protected、默认不写、private

2）权限范围总结：public：访问权限最大，整个Java工程中可以随意调用

                                protected：只能在同一包下类使用，不同的包中的类可以通过继承来使用

                                默认不写：只能在同一包下类使用， 不同的包中的类不可以通过继承来使用

                               private：访问权限最小，只能在当前类中使用

3）使用范围总结：四个访问权限都可以修饰方法与属性、但是只要public和默认不写可以修饰类

4.final与instanceof

1)final的英文含义是最后的，也就是不能被修改的意思，final可以修饰类、方法、属性、以及参数

   注意：当类被修饰为final时，该类表示为最后的类了，所以不能被继承了，因此final不能修饰抽象类与接口的，因为抽象类与接口都不能创建对象

             当方法被修饰final时、表示该方法为最后的方法了，所以该方法不能被重写，因此不能修饰抽象方法，因为抽象方法本来就是来约束方法，进行重写的

              当属性被修饰为final时，表示属性为最后的属性了，所以该属性不能被重新赋值，而且必须在开始定义该属性时便赋值或者

              通过构造方法传参来赋值，一旦赋了值，该值就不会被改变

              当参数被修饰为final时，表示该参数在本方法体内不能被修改值

2）instanceof的作用：用来判断当前对象的转型子类对象是什么类型

                                      格式：Boolean 变量名 = 父类对象 instanceof 子类类型

         比如：有两个子类，一个为student类、一个为teacher类，而这两个子类都继承于person类，当自动转型后，想知道创建的对象到底是student类还是teacher类

        便可以通过instanceof的方法来判断

      //自动转型
        Person person = new Student(); 
        Person person1 = new Teacher();
     //判断person对象是哪个类型
     Boolean boolean =  person instanceof Student

5.循环判断结果

1）循环结构:for、while、do...while

2）判断结构：if...else、switch

3）注意：do...while循环、无论前提条件是否满足，程序至少会执行一次

                 switch判断只支持int与string类型的判断

6.this与super关键字

1）this与super的定义：this代指当前类的对象，而super代指的是父类的对象

2）通过this来调用属性与方法的格式：调用属性：this.属性、

                                                                  调用方法：this.方法名();

                                                                     调用构造方法：this();

3)通过this来调用构造方法一般只会在构造方法中调用其他的构造方法，而且通过this来调用构造方法只能写在方法的第一行

public class Test{
   public String name;  
 //无参构造方法
   public Test(){
// 必须写在第一行，this前面不能有其他该方法内的程序段
    this.("");
}
  //有参构造方法
  public Test(String name){
   this.(20,"");
}
   //有两个参数的构造方法
  public Test(int a ,String name){
}
}

4)通过super来调用属性与方法的格式：调用属性：super.属性

                                                               调用方法:super.方法名（）；

                                                             调用构造方法：super（）；

5)子类重写父类的方法时，一般会在重写的方法里自动添加super.重写方法名（），用于对父类方法的补充

/**
   *父类
*/
public class Test{
      public void say(){

}
}

public class Test1 extends Test{
        public void say(){
             super.say();
       //下面是对父类方法的补充，比如输出一行话
      System.out.println("你好");
   
}
}

6）子类的构造方法一定会调用父类的构造方法，其作用为初始化父类的对象，并继承父类的属性与方法（如果不调用父类的构造方法，便没有父类的对象，没有对象就不能调用父类的属性与方法，无参的构造方法可以省略）

public class Test{
  int a ;      
public Test(int a){
    
}
}

public class Test1 extends Test{
    
    public Test1(int a){

   //一定会调用父类的构造方法
   super(a);
}  
}

7）调用父类的构造方法也必须要写在方法体的第一行，不然程序会报错

7.static关键

1）static关键字可以修饰类。方法，属性，静态快

2）static修饰的属性和方法，初始化时间与类同步，而static修饰的成员变量与方法，初始化时间与对象同步

3）静态代码块的表示方法：static{}，一定要注意，静态的和类同步，非静态的与对象同步

public class Teacher {
    public static String name;	
//代码块：创建对象的时候，自动执行
	{
		System.out.println(1);
	}
	static{
		System.out.println(2);
	}
	
	public Teacher() {
		System.out.println(3);
	}
	
	public void play(){
		System.out.println(4);
	}
	public static void teach(){
		System.out.println(5);
	}
}

public class Test {
	public static void main(String[] args) {
		Teacher tea1 = new Teacher();
		Teacher tea2 = new Teacher();
		tea1.play();
		Teacher.teach();
		
                tea1.name = "李四";
                tea2.name = "王五";
		Teacher.name = "张三";
		
		System.out.println(Teacher.name);
	        System.out.println(tea1.name);
		System.out.println(tea2.name);
		
		

	}
}

由以上代码可以知道在teacher类中一次添加了代码块，静态代码块，teacher的构造方法，teacher类的普通方法play与teacher类的静态方法teach，

代码块的执行时在teacher类对象创建时执行的，静态代码块是在类加载时执行的，teacher的构造方法也是在创建对象时执行的，但是构造方法的执行要慢与

代码块的执行，普通方法的执行时在teacher对象调用该方法时执行，而静态方法也是在方法被调用时执行

所以当程序创建了两个对象时，会执行静态代码块与代码块以及构造方法，注意，一个类只会加载一次，不会因为创建了多少个对象而再次加载，之后再分别调用了

play与teach方法，注意静态方法的调用可以通过类名.方法名的方式来调用，所以控制台输出的是2131345

在调用方法后，在下面依次对不同对象的name进行了赋值，输出操作，但是最后控制台的输出却是取决于最后一个队name赋值的值，因为在teacher类中用static

对name变量进行了修饰，所以name变量并不会被存到内存中的堆空间里，而是存到内存中的static静态空间里，所以上面对name的赋值，其实是对同一个变量进行赋值

之前赋的值会被后面的赋值操作所覆盖，所以最后在控制台输出的name值为三个张三。