final关键字
- 被其修饰的类，不能被继承。
- 被其修饰的方法，不能被覆盖。
- 被其修饰的变量，是一个常量，不能被修改，所以定义时必须初始化（和C++的const类似）。
一般有final，会搭配static使用。如
final static double PI = 3.14;
- 常量的命名规则 --> 所有字母大写，多个单词，中间用下划线连接。
抽象类
猫和狗有共性，将共性抽取出来，放入Animal中，Animal是抽象的（想象不出实体是什么）。
public abstract class Animal {
// 抽象类也有构造函数，给子类初始化用
public Animal() {
System.out.println("我们都是动物");
}
public abstract void eat();
}
// 也可以存在非抽象函数
public void sleep() {
System.out.println("睡觉了zzz~");
}
}
class Cat extends Animal {
Cat() {
System.out.println("我是一只小猫咪");
}
@Override
public void eat() {
System.out.println("小猫吃鱼");
}
}
class Dog extends Animal {
Dog() {
System.out.println("我是一条小狗狗");
}
@Override
public void eat() {
System.out.println("狗狗啃骨头");
}
}
public class Demo {
public static void main(String args[]) {
public static void main(String[] args) {
Animal a = new Cat();
a.eat();
a.sleep();
// 打印如下内容
// 我们都是动物
// 我是一只小猫咪
// 小猫吃鱼
// 睡觉了zzz~
}
}
因为类Cat、类Dog或者其他类要继承类Animal，且类Animal的show()是抽象的未被定义的，子类必须覆盖父类的方法，定义自己特有的eat()方法（猫和狗吃的东西不全一样），故在抽象类中的方法只是声明。
抽象类的特点
- 方法只有声明没有实现，为抽象方法，修饰符abstract，抽象方法必须在抽象类中。
- 抽象类不可以实例化，即不能new。因为调用抽象方法没有意义。
- 子类必须覆盖抽象类的所有抽象方法后，该子类才能实例化，否则还是抽象类。
Q：抽象类有没有构造函数？
A：有，用来给子类初始化，如上例，最先打印我们都是动物。
Q：可以没有抽象方法吗，或者说，可以不全是抽象方法吗？
A；可以。但是接口interface必须全是抽象方法。
abstract关键字不能和哪些关键字共存
- private：因为子类要覆盖抽象类的抽象方法，私有后不可访问，怎么覆盖？
- static：抽象类中只是声明了，子类需要重写抽象类的方法。而静态方法不能被重写，所有矛盾了。
- final：final修饰的方法不能被覆盖，子类要覆盖啊，所以不能加。
接口-interface
当一个抽象类中全部是抽象方法时，可将其定义为interface。
- 变量规定为：public static final，即使写成int a，也被认为是
public static final int a; - 方法规定为：public abstract
- 接口中的成员，都是public的
接口和抽象类一样，不可实例化，用来给其他类扩展功能，接口与接口之间为继承关系，接口可以多继承。Java不支持直接多继承，改成了多实现，即一个子类多个接口，解决了单继承的局限性。
抽象类和接口
抽象类只能被单继承，接口可以背多实现。
抽象类中也可以定义非抽象方法，子类可以直接用非抽象方法。接口中只能定义抽象方法。共同点是，其抽象方法都必须被重写。
抽象类定义基本的共性内容，接口是定义额外的功能。
多态
对于Animal a = new Cat()，new出子类，却让父类指向子类，就叫多态。
public void method(Animal a) {
a.eat(); // 运行时根据具体传入的实参，来调用对应的方法
// 若Dog和Cat都继承了Animal，参数传入Dog就执行dog.eat(),传入Cat就执行cat.eat()
// 这有点像C++中的动态绑定
}
// 和以下函数重载比较起来，是不是方便了
public void method(Dog a) {
a.eat()
}
public void method(Cat a) {
a.eat();
}
多态好处
从上例可以看出，多态的好处：前期定义的代码可以用于后期，比如再来一个Wolf类继承Animal，就可以传入wolf调用以上函数，传入的就是wolf了。
多态缺点
前期定义的内容，不可调用后期子类的特有内容。举个例子
public void method(Animal a) {
a.eat(); // 父类定义了该方法
a.catchMouse(); // Animal没有定义“抓老鼠”的方法，若是传入的参数不是Cat，则报错
}
// 怎么解决？强转回来！如下
public void method(Animal a) {
a.eat();
// 先判断传入的实参，若是Cat，进行强转回Cat后，再执行“抓老鼠”
if (a instanceof Cat）{
Cat c = (Cat)a;，
c.catchMouse();
}
// 若传入的是狗，就执行“叫”
if (a instanceof Dog) {
Dog d = (Dog)a;
d.bark();
}
}
Animal a = new Cat();
- 若子类没有覆盖父类的方法，就调用父类自己的方法。
- 若子类调用了自己特有的方法，父类并没有定义该方法，则编译不通过。Cat类型提升为Animal后，Cat特有的方法会被舍弃，与Animal同名的函数被覆盖。
换个说法，a是Animal，它只能用Animal定义过的方法和变量，但执行函数时实际执行的是Cat的重写方法。总的来说，如下
- 对于成员变量，和静态函数：编译和运行都是看父类是否具有该变量和静态，若a调用了Cat独有的变量，则报错。
- 对于成员函数，编译时候检查Animal是否定义该方法，运行时候执行子类重写的方法，若子类没有重写，自然执行父类的。
内部类-嵌套类
public class Out {
private String out;
private class In {
private String in;
}
}
- 内部类可以直接访问外部类的成员（private的也行）
- 但是外部类要访问内部类，必须建立内部类的对象。
- 内部类也可以是static的，这是，内部类随着外部类的加载而加载，相当于是外部类。
Out.In in = new Out().new In(); // 非static内部类的实例化
Out.In in = new Out.In(); // static内部类可以这样实例化
In in = new In(); // static内部类也可以这样实例化，相当于外部类了，仅在本例有效
如果内部类用到了静态成员，则内部类必须是static的。
同名变量的访问。
public class Out {
private int num = 1;
private class In {
int num= 2;
public void show() {
int num = 3;
System.out.println(num); // 打印3
System.out.println(this.num); // 打印2
System.out.println(Out.this.num); // 打印1
}
}
}
方法内部的内部类
public class Out {
public void func() {
// num是func方法中的局部变量，func中又定义了内部类，用到这个num，该num必须是final的
final int num = 1;
// java8中，会默认加上final，所以可以直接int num = 1；
class In {
public void show() {
System.out.println(num);
}
}
}
}
方法里的内部类不能访问外部类方法中的局部变量，除非变量被声明为final类型，因为内部类对象的生命周期超过局部变量的生命周期。有可能出现成员方法已调用结束，局部变量已死亡，但匿名内部类的对象仍然活着。
Java 8中：如果局部变量被匿名内部类访问，那么该局部变量相当于自动使用了final修饰。
匿名内部类
若一个程序的某个类只使用了一次，则可定义为匿名内部类，用完就消亡。条件是必须继承或者实现一个外部类或者接口。
abstract class Person {
public abstract void eat();
}
// 不用内部类的情况，需要再写一个类继承Person覆盖方法
class Child extends Person {
@Override
public abstract void eat() {
System.out.println("Child eat");
}
}
public class Out {
public static void main(String[] args) {
// 匿名内部类，这里相当于继承了抽象类Person，新写了一个无名的子类，并覆盖了eat方法
new Person() {
public void eat() {
System.out.println("eat something");
}
}.eat();
}
}
下面内容转自Nerxious-博客园，总得得不错，特地搬过来。
// 不使用匿名内部类
abstract class Person {
public abstract void eat();
}
class Child extends Person {
public void eat() {
System.out.println("eat something");
}
}
public class Demo {
public static void main(String[] args) {
Person p = new Child();
p.eat();
}
}
//运行结果：eat something
// 可以看到，我们用Child继承了Person类，然后实现了Child的一个实例，将其向上转型为Person类的引用但是，如果此处的Child类只使用一次，那么将其编写为独立的一个类岂不是很麻烦？这个时候就引入了匿名内部类
// 匿名内部类的基本实现
abstract class Person {
public abstract void eat();
}
public class Demo {
public static void main(String[] args) {
Person p = new Person() {
public void eat() {
System.out.println("eat something");
}
};
p.eat();
}
}
//运行结果：eat something
// 可以看到，我们直接将抽象类Person中的方法在大括号中实现了这样便可以省略一个类的书写并且，匿名内部类还能用于接口上
// 在接口上使用匿名内部类
interface Person {
public void eat();
}
public class Demo {
public static void main(String[] args) {
Person p = new Person() {
public void eat() {
System.out.println("eat something");
}
};
p.eat();
}
}
//运行结果：eat something
// 由上面的例子可以看出，只要一个类是抽象的或是一个接口，那么其子类中的方法都可以使用匿名内部类来实现。最常用的情况就是在多线程的实现上，因为要实现多线程必须继承Thread类或是继承Runnable接口
// Thread类的匿名内部类实现
public class Demo {
public static void main(String[] args) {
Thread t = new Thread() {
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.print(i + " ");
}
}
};
t.start();
}
}
// 运行结果：1 2 3 4 5
// Runnable接口的匿名内部类实现
public class Demo {
public static void main(String[] args) {
Runnable r = new Runnable() {
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.print(i + " ");
}
}
};
Thread t = new Thread(r);
t.start();
}
}
// 运行结果：1 2 3 4 5
by @sunhiayu
2016.12.11
