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不能修饰局部变量！
查看博客/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修饰的变量称为常量，这些变量只能赋值一次。引用类型的变量值为对象地址值，地址值不能更改，但是地址内的对象属性值可以修改。
finalPerson p=newPerson();
Person p2=newPerson();
p= p2; //final修饰的变量p，所记录的地址值不能改变
p.name= "小明";//可以更改p对象中name属性值
//p不能为别的对象，而p对象中的name或age属性值可更改。
5. 修饰成员变量，需要在创建对象前赋值，否则报错。(当没有显式赋值时，多个构造方法的均需要为其赋值。)
classDemo {
//直接赋值
finalintm= 100；
//final修饰的成员变量，需要在创建对象前赋值，否则报错。
finalintn;
publicDemo(){
//可以在创建对象时所调用的构造方法中，为变量n赋值
n= ;
}
}
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方法，主要用于测试代码
