this super package import static final abstract interface.
this
1.使用在类中，可以用来修饰属性、方法、构造器
2.表示当前对象或者是当前正在创建的对象
3.当形参与成员变量重名时，如果在方法内部需要使用成员变量，必须添加this来表明该变量时类成员
4.在任意方法内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性
5.在构造器中使用“this(形参列表)”显式的调用本类中重载的其它的构造器
>5.1 要求“this(形参列表)”要声明在构造器的首行！
>5.2 类中若存在n个构造器，那么最多有n-1构造器中使用了this。
package
package:声明源文件所在的包，写在程序的第一行。
每“.”一次，表示一层文件目录。
包名都要小写。
import
* 1)显式导入指定包下的类或接口
* 2)写在包的声明和源文件之间
* 3)如果需要引入多个类或接口，那么就并列写出
* 4)如果导入的类是java.lang包下的，如：System String Math等，就不需要显式的声明。
* 5)理解.*的概念。比如java.util.*;
* 6)如何处理同名类的导入。如：在util包和sql包下同时存在Date类。
* 7)import static 表示导入指定类的static的属性或方法
* 8)导入java.lang.*只能导入lang包下的所有类或接口，不能导入lang的子包下的类或接口
super
1.super，相较于关键字this，可以修饰属性、方法、构造器
2.super修饰属性、方法：在子类的方法、构造器中，通过super.属性或者super.方法的形式，显式的调用父类的指定
属性或方法。尤其是，当子类与父类有同名的属性、或方法时，调用父类中的结构的话，一定要用“super.”
3.通过“super(形参列表)”，显式的在子类的构造器中，调用父类指定的构造器！
>任何一个类(除Object类)的构造器的首行，要么显式的调用本类中重载的其它的构造器“this(形参列表)”或显式的调用父类中
指定的构造器“super(形参列表)”,要么默认的调用父类空参的构造器"super()"
>建议在设计类时，提供一个空参的构造器！
static
1.static:静态的，可以用来修饰属性、方法、*代码块（或初始化块）、*内部类
2.
static修饰属性（类变量）:
* 1.由类创建的所有的对象，都共用这一个属性
* 2.当其中一个对象对此属性进行修改，会导致其他对象对此属性的一个调用。vs 实例变量（非static修饰的属性，各个对象各自拥有一套副本）
* 3.类变量随着类的加载而加载的，而且独一份
* 4.静态的变量可以直接通过“类.类变量”的形式来调用
* 5.类变量的加载是要早于对象。所以当有对象以后，可以“对象.类变量”使用。但是"类.实例变量"是不行的。
* 6.类变量存在于静态域中。
*
static修饰方法（类方法）:
* 1.随着类的加载而加载，在内存中也是独一份
* 2.可以直接通过“类.类方法”的方式调用
* 3.内部可以调用静态的属性或静态的方法，而不能调用非静态的属性或方法。反之，非静态的方法是可以调用静态的属性或静态的方法
* >静态的方法内是不可以有this或super关键字的！
* 注：静态的结构(static的属性、方法、代码块、内部类)的生命周期要早于非静态的结构，同时被回收也要晚于非静态的结构
* (工具类一般都是静态的)
static代码块
* 在类加载完之后就会执行代码块中的内容。
static内部类
* 父类静态代码块->子类静态代码块->父类非静态代码块->父类构造方法->子类非静态代码块->子类构造方法
例子
public class TestCircle {
public static void main(String[] args) {
Circle c1 = new Circle();
Circle c2 = new Circle(2.3);
System.out.println(c1);
System.out.println(c2);
System.out.println(Circle.getTotal());
}
}
class Circle{
private double radius;
private static String info = "我是一个圆";
private int id;//编号
private static int init = 1001;//控制每个对象的id
private static int total = 0;//记录创建了多少个对象
public Circle(){
this.id = init++;
total++;
}
public Circle(double radius){
this.radius = radius;
this.id = init++;
total++;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
public static String getInfo() {
return info;
}
public static void setInfo(String info) {
Circle.info = info;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public static int getTotal() {
return total;
}
public static void setTotal(int total) {
Circle.total = total;
}
@Override
public String toString() {
return "Circle [radius=" + radius + ", id=" + id + "]";
}
public static void show(){
System.out.println(Circle.info);
}
public void desc(){
System.out.println(this.info);
}
}
final
/*
* final:最终的 ，可以用来修饰类、属性、方法
*
* 1.final修饰类：这个类就不能被继承。如：String类、StringBuffer类、System类
*
* 2.final修饰方法：不能被重写。如：Object类的getClass()
*
* 3.final修饰属性：此属性就是一个常量，一旦初始化后，不可再被赋值。习惯上，常量用大写字符表示。
* 此常量在哪里赋值：①此常量不能使用默认初始化 ②可以显式的赋值、代码块、构造器。
*
* 变量用static final修饰：全局常量。比如：Math 类的PI
*
* >与finally finalize()区分开
*
*/
class D{
final int I = 12;
final double PI;
final String NAME;
public void m1(){
System.out.println(I);
// I = 10;
}
{
PI = 3.14;
}
public D(){
NAME = "DD";
}
public D(String name){
this();
//NAME = name;
}
}
abstract
重点！
abstract：抽象的，可以用来修饰类、方法
* 1.abstract修饰类：抽象类
* 1)不可被实例化
* 2)抽象类有构造器 (凡是类都有构造器)
* 3)抽象方法所在的类，一定是抽象类。
* 4)抽象类中可以没有抽象方法。
* >当我们设计一个类，不需要创建此类的实例时候，就可以考虑将其设置为抽象的，由其子类实现这个类的抽象方法以后，就行实例化
*
* 2.abstract修饰方法：抽象方法
* 1)格式：没有方法体，包括{}.如：public abstract void eat();
* 2)抽象方法只保留方法的功能，而具体的执行，交给继承抽象类的子类，由子类重写此抽象方法。
* 3)若子类继承抽象类，并重写了所有的抽象方法，则此类是一个"实体类",即可以实例化
* 4)若子类继承抽象类，没有重写所有的抽象方法，意味着此类中仍有抽象方法，则此类必须声明为抽象的！
* abstract 不能用来修饰属性、构造器、private、final、static
interface
* 接口（interface） 是与类并行的一个概念
* 1.接口可以看做是一个特殊的抽象类。是常量与抽象方法的一个集合，不能包含变量、一般的方法。
* 2.接口是没有构造器的。
* 3.接口定义的就是一种功能。此功能可以被类所实现（implements）。
* 比如：class CC extends DD implements AA
* 4.实现接口的类，必须要重写其中的所有的抽象方法，方可实例化。若没有重写所有的抽象方法，则此类仍为一个抽象类
* 5.类可以实现多个接口。----java 中的类的继承是单继承的
* 6.接口与接口之间也是继承的关系，而且可以实现多继承
* >5,6描述的是java中的继承的特点。
* 7.接口与具体的实现类之间也存在多态性
* 8.面向接口编程的思想：
接口用法总结
通过接口可以实现不相关类的相同行为，而不需要考虑这些类之间的层次关系。
通过接口可以指明多个类需要实现的方法，一般用于定义对象的扩张功能。
接口主要用来定义规范。解除耦合关系。
