static关键字
被static修饰的成员变量和成员方法独立于该类的任何对象，
它不依赖类特定的实例，被类的所有实例共享。
当创建对象后，成员变量是存储在堆中的，而static成员变量和类的信息一起存储在方法区, 而不是在堆中。
static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问
访问方式： 类名.类变量 或者 实例名.类变量double c = Math.sqrt(3.0 * 3.0 + 4.0 * 4.0);
super关键字
super必须是子类构造方法的第一条语句 用来引用父类中的变量、方法以及构造方法。
final关键字如果final是在类之前，则说明该类是最终类，不能被继承如果final是在方法之前，该方法不能被任何派生的子类覆盖（重写）如果final写在变量之前，说明该变量的值在初始化之后就不能再改变，相当于定义了一个常量。
static final常量
static final 修饰的成员变量称为常量，必须声明同时初始化，并且不可被改变。常量建议所有字母大写。
public class TestStudent
{
private static final int NUM =10;
public static void main(String[] args)
{System.out.println(NUM);
}
继承
子类（Sub class）可以继承父类（Super class）的成员变量及成员方法，也可以定义自己的成员变量和成员方法。
public class Person extends Student{public Person(String name, String stuNo) {super(name, stuNo);}}
子类的构造方法中是必须要通过super关键字来调用父类的构造方法
父类的引用 指向 子类的对象
父类
class Foo{
int value;
public void f(){...}
Foo(int value){
this.value = value;
}
}
子类
class Goo extends Foo{
int num;
public void g(){...}
Goo(int value;int num)
{
super(value)
this.num = num;
}
}
class Test{
public static voi
d main (String[]args)
{
Foo obj =new Goo(100,3); //父类的引用 指向 子类的对象
}}
父类的引用只能访问父类定义的成员
不能访问子类 扩展的部分
方法的重写
子类可以重写（覆盖）继承自父类的方法，即方法名和参数列表与父类的方法相同，但是方法的实现不同。
子类重写了父类的方法后，该重写方法被调用时（无论是通过子类的引用调用还是通过父类的引用调用），运行的都是子类重写后的版本。//动态绑定
父类
class Foo{
public void f(){
System.out.println("Foo.f()");
}
}
子类
class Goo extends Foo{
public void f(){
System.out.println("Goo.f()")
}
}
class Test{
public static void main (String []args)
{
Goo obj1=new Goo();
obj1.f();
Foo obj2=new Goo();
obj2.f();
}
}
输出结果均为“Goo.f()”，因为都是Goo的对象，所以无论是子类的引用还是父类的引用，最终运行的都是子类重写后的版本。
重写中使用super关键字
在子类重写的方法中，可以通过super关键字调用父类的版本
子类
class Goo extends Foo{
public void f(){
super.f();
System.out.println("Goo.f()");
}
}
测试类
class Test{
public static void main (String[]args)
{
Foo obj2=new Goo();
obj2.f();
}
}
super.f()即可调用父类Foo的f()方法
此程序输出结果：Foo.f() Goof()
这样的语法通常用于子类的重写方法在父类方法的基础之上进行的功能扩展。
重载： 是指在一个类中定义多个方法名相同但参数列表不同的方法，在编译时，根据参数的个数和类型来决定绑定哪个方法。重载遵循所谓“编译期绑定”。
重写： 是指在子类中定义和父类完全相同的方法，在程序运行时，根据对象的类型（而不是引用类型）而调用不同的方法。重写遵循所谓“运行期绑定”。
抽象方法和抽象类
abstract修饰的方法为抽象方法,
抽象方法即只有方法的定义，没有方法体实现，用一个分号结尾。抽象方法缺少了一个要素（即：方法体）
抽象类是不能实例化对象的
一个类不能实例化是没有意义的，所以，需要定义类来继承抽象类，而如果一个类继承了抽象类，则其必须重写其抽象方法（变不完整为完整），除非该类也声明为抽象类。
抽象类
抽象类用abstract关键字修饰；
抽象类必须被继承；
抽象类不能被直接实例化；
抽象类只能作为其他类的父类。
抽象方法
抽象方法用abstract关键字修饰；
抽象方法必须被重写；
抽象方法只有声明，不能有具体的实现；
定义抽象方法的类只能是抽象类。
抽象类的意义
为其子类提供一个公共的类型（父类引用指向子类对象）； 定义有抽象方法，子类虽然有不同的实现，但该方法的定义是一致的。(子类需要实现此抽象方法)。
需要注意一点：abstract和final关键字不可以同时用于修饰一个类，因为final关键字使得类不可继承，而abstract修饰的类如果不可以继承将没有任何意义。两者放在一起，会起冲突。
定义抽象类AbstractClass ：
public abstract class AbstractClass
{
private double c;public abstract void sum();
}
一个类继承抽象类后，必须实现其抽象方法，不同的子类可以有不同的实现。
接口
可以通过interface关键字来定义接口。
interface Runner
{
public static int DEFAULT_SPEED = 100;
public void run();
}
与继承不同，一个类可以实现多个接口，实现的接口直接用逗号分隔。当然，该类需要实现这些接口中定义的所有方法；
一个类可以通过implements关键字”实现”接口。一个类实现了某个接口后必须实现该接口中定义的所有方法。
class AmericanCurl implements Runner , …
{
public void run() {
System.out.println("run...");}
}
接口的继承
接口间可以存在继承关系，一个接口可以通过extends关键字继承另外一个接口。子接口继承了父接口中定义的所有方法。
interface Runner {
public void run();}
interface Hunter extends Runner {public void hunt();
}
class AmericanCurl implements Hunter {public void run() {… … …} public void hunt() {… … …} }
接口和抽象类的区别：
1.一个类只能继承一个抽象类，但可以实现多个接口。 2.抽象类中可以包含抽象方法和非抽象方法，而接口中的所有方法均为抽象的。
3.子类继承抽象类必须实现抽象类中所有抽象方法，否则子类也必须是抽象类。而子类实现接口则必须实现接口中的所有抽象方法。
多态
多态即多种形态，主要有两个方面的表现。1.一个类型的引用在指向不同的对象时会有不同的实现。
Person one = new Person("lxx", "20170607",23);
Student two = new Person("lxx","2010709",23);
one.aa();two.aa();
2.同样一个对象，造型成不同的类型时，会有不同的功能.讲师 teacher = new 讲师();
技术顾问 consultant = teacher;
图书作者 author = teacher;consultant.培训员工();author.编辑稿件();
重写和重载都是属于多态的表现形式。