Java关键字详解this、private、static、super、extends继承、instanceof、final、abstract、interface、implements、enum...

1，this

//在方法中出现了局部变量和成员变量同名的时候，可以在成员变量名前面加上this.来区别成员变量和局部变量。

//1.在构造调用另一个构造函数，调用动作必须置于最起始的位置，即this()放在构造函数第一行。 2.不能在构造函数以外的任何函数内调用构造函数。 3.在一个构造函数内只能调用一个构造函数。

public class ThisTest {
private int age;
private String str;

ThisTest(String str) {
this.str=str;
System.out.println(str);
}
ThisTest(String str,int age) {
this(str); //this()放在构造函数第一行
this.age=age;
System.out.println(age);
}

public static void main(String[] args) {
ThisTest thistest = new ThisTest("this测试成功",25);

}
}

2，private：

//private不能修饰局部变量！

查看博客https://blog.csdn.net/krismile__qh/article/details/88668456

3，static（记住凡是被static修饰的都是属于类，不属于具体的对象）

1. static方法：被static修饰的成员可以并且建议通过类名直接访问。类名.属性；类名.方法名();

静态方法不可以操作非静态变量！

2. static成员变量：

3. static代码块：属于类，只被执行一次

还有一个局部代码块，位置在方法中；

4. 注：1>静态内容是优先于对象存在，只能访问静态，不能使用this/super。静态修饰的内容存于静态区。2>同一个类中，静态成员只能访问静态成员。

4，super

在JAVA类中使用super来引用父类的成分，用this来引用当前对象，如果一个类从另外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。怎么去引用里面的父类对象呢？使用super来引用，this指的是当前对象的引用，super是当前对象里面的父对象的引用。

注：super() 与 this() 必须放在构造函数第一行且不能同时存在；

代码示例：

package cn.galc.test;

/**
* 父类
* @author gacl
*
*/
class FatherClass {
public int value;
public void f() {
value=100;
System.out.println("父类的value属性值="+value);
}
}

/**
* 子类ChildClass从父类FatherClass继承
* @author gacl
*
*/
class ChildClass extends FatherClass {
/**
* 子类除了继承父类所具有的valu属性外，自己又另外声明了一个value属性，
* 也就是说，此时的子类拥有两个value属性。
*/
public int value;
/**
* 在子类ChildClass里面重写了从父类继承下来的f()方法里面的实现，即重写了f()方法的方法体。
*/
public void f() {
super.f();//使用super作为父类对象的引用对象来调用父类对象里面的f()方法
value=200;//这个value是子类自己定义的那个valu，不是从父类继承下来的那个value
System.out.println("子类的value属性值="+value);
System.out.println(value);//打印出来的是子类自定义的那个value的值，这个值是200
/**
* 打印出来的是父类里面的value值，由于子类在重写从父类继承下来的f()方法时，
* 第一句话“super.f();”是让父类对象的引用对象调用父类对象的f()方法，
* 即相当于是这个父类对象自己调用f()方法去改变自己的value属性的值，由0变了100。
* 所以这里打印出来的value值是100。
*/
System.out.println(super.value);
}
}

/**
* 测试类
* @author gacl
*
*/
public class TestInherit {
public static void main(String[] args) {
ChildClass cc = new ChildClass();
cc.f();
}
}

5，extends

继承：一个类里面有很多的功能，如果我想拓展这个类，而这个类又不允许你修改，你只能继承这个类，并拓展你的功能即可

1、为什么要继承？为了增强一个类的功能，并且代码看着有层次
2、继承使用什么写法：类 extends 父类
3、理论讲父类的所有东西除了私有的，子类能使用
4、调用子类，子类会自动实例化父类，调用父类的无参构造方法
5、如果想调用父类的有参数的构造方法 super(参数)

子父类中成员方法的特点：当在程序中通过对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。

成员方法特殊情况——覆盖：子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为override重写、复写或者覆盖。

//注：重写需要注意的细节问题

子类方法覆盖父类方法，必须要保证权限大于等于父类权限。

class Fu(){

void show(){}

public void method(){}

}

class Zi() extends Fu{

@Override//重写时打上这个字符串，起检测作用，检测这个方法是不是重写，是就不报错，否则报错

public void show(){} //编译运行没问题

void method(){} //编译错误

}

2. 写法上稍微注意:必须一模一样:方法的返回值类型方法名参数列表都要一样。

总结：当一个类是另一个类中的一种时，可以通过继承，来继承属性与功能。如果父类具备的功能内容需要子类特殊定义时，进行方法重写。

6，instanceof

通过 instanceof关键字来判断某个对象是否属于某种数据类型.

如学生的对象属于学生类，学生的对象也属于人类。

7，final

final 可以修饰一个参数，可是该参数不能再在方法中赋值！

//final的意思为最终，不可变。final是个修饰符，它可以用来修饰类，类的成员，以及局部变量。

//注：1.如何定义一个常量，必须public static final，必须名字大写，public static final float PI = 3.1415f; 2.String类是final类

//final的特点：

final修饰类不可以被继承，但是可以继承其他类。
final修饰的方法不可以被覆盖,但父类中没有被final修饰方法，子类覆盖后可以加final。
final修饰的变量称为常量，这些变量只能赋值一次。
引用类型的变量值为对象地址值，地址值不能更改，但是地址内的对象属性值可以修改。

final Person p = new Person();

Person p2 = new Person();

p = p2; //final修饰的变量p，所记录的地址值不能改变

p.name = "小明";//可以更改p对象中name属性值

//p不能为别的对象，而p对象中的name或age属性值可更改。

5. 修饰成员变量，需要在创建对象前赋值，否则报错。(当没有显式赋值时，多个构造方法的均需要为其赋值。)

class Demo {

//直接赋值

final int m = 100；

//final修饰的成员变量，需要在创建对象前赋值，否则报错。

final int n;

public Demo(){

//可以在创建对象时所调用的构造方法中，为变量n赋值

n = 2016;

}

8，abstract

1、抽象类和抽象方法都需要被abstract修饰。抽象方法一定要定义在抽象类中，抽象方法没有方法体，用分号结尾。而抽象类中可以没有抽象方法，也可以有具体的方法。

2、抽象类不可以直接创建对象(即不能被实例化)，原因：调用抽象方法没有意义。但抽象类却有构造方法，抽象类的构造方法只是为了让子类调用。

3、只有覆盖了(重写)抽象类中所有的抽象方法后，其子类才可以创建对象。否则该子类还是一个抽象类，即抽象子类可以不重写父类的抽象方法。

4、abstract只能修饰类和方法！不能修饰变量。

5、final、private、static和abstract不能同时存在！

之所以继承抽象类，更多的是在思想，是面对共性类型操作会更简单。

9、interface

接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象的”类”。

接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离，优化了程序设计。

类和接口是平级关系，类通过class 修饰，接口以interface修饰。定义接口所在的仍为.java文件，虽然声明时使用的为interface关键字，编译后仍然会产生.class文件。
定义格式：

public interface 接口名 {

抽象方法1;

抽象方法2;

抽象方法3;

}

3.使用interface代替了原来的class，其他步骤与定义类相同：(与抽象类的不同之处)

1>接口中的方法均为公共访问的抽象方法

(特殊情况说明：

1）如果接口中被static修饰，该方法必须有方法体

2）如果接口中的方法被default修饰，该方法必须有方法体)

2>接口中无法定义普通的成员变量，一般是常量，常量一般是public static final修饰

4. 接口不能被实例化，接口没有构造方法

5. 一个类可以实现多个接口 public class A implements B,C...{}，一个实现类必须实现接口中的所有抽象方法，即重写。

6. 一个接口可以继承另一个接口 public interface A extends B,C..{}，接口之间是多继承，类之间是单继承。

7. 一个类可以extends 父类，并且 implements 接口A,B...

8. 子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。

10，default

用法：1) switch 2) 接口中修饰方法时 default
不要和这种混淆： public protected 无 private

11，enum(枚举)

1.枚举是引用数据类型。枚举类实际上就是声明了同一类型的一堆常量，便于使用和查看；

2.声明枚举：

格式：

public enum 枚举名{

//枚举的取值范围

//枚举中可以声明方法

}

例如：

//声明一个表示季节的枚举
       public enum Season{
SPRING,
   SUMMER,
   AUTUMN,
   WINTER;
   public void fun(){}
       }

3.注意：

1.枚举中的成员是此枚举的取值范围;

2.所有的值之间使用逗号分隔，最后一个值后可以加分号也可以不加分号;

3.在枚举中可以声明方法，但是必须在所有的取值之后声明，而且最后一个值后必须使用分号隔开

4.枚举的本质：其实就是终止类final，不能被继承，并继承Enum类Public abstract calss Enum{}

5.枚举中的变量，其实就是一个当前类型的静态常量。

4.枚举类型举例：

SPRING 是常量，是Season的一个实例化对象,默认调用的是他的无参构造方法
如果编写了有参数的构造方法，这些常量对象就要传递参数了，这个里面的构造方法是默认访问权限
枚举类中也可以有普通方法

5. 枚举结合switch结构使用

public class TestSeasonEnmu{
public static void main(String[]args){
//声明一个枚举变量
Season season = Season.SPRING;
//switch小括号中的表达式类型可以是枚举类型
switch(season){
//每个case后的常量直接写枚举的取值范围
case SPRING:
System.out.println("春天");
break;
case SUMMER:
System.out.println("夏天");
break;
case AUTUMN:
System.out.println("秋天");
break;
case WINTER:
System.out.println("冬天");
break;
}
}
}

6.补充一下单元测试：

单元测试：

1. 一个普通类，编写一个方法
2. 这个方法必须是public ，必须是void返回，建议方法名称是test开头，千万不要将类名写成Test
3. 方法上必须写@Test注解，如果报错，导入包
4. 单元测试类似于main方法，主要用于测试代码