java接口和抽象类有局部变量_Java基础之接口与抽象类及多态、内部类

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