java基础知识---多态、抽象类、接口、内部类

一、多态

java中学过继承之后，有一个非常重要的概念需要我们理解，这就是多态。

多态，可以理解为一个事物在不同时刻体现出的不同的状态。就比如水一样，它可以有固态、液态、气态。从这个概念中可以看出要实现多态，继承是必不可少的，而且不同的状态可以看出其中必定有方法重写。这是多态中不可缺少的前提条件之一。

多态的声明格式为： 父类名   对象=new 子类名。

直白的说就是将父类的引用指向子类对象（也叫向上转型），这个也是多态必不可少的条件。

给出一个多态的例子来具体分析吧

//父类
class Fu{
public int num = 10 ;

//父类的成员方法
public void show(){
System.out.println("show Fu...");
}
}
//子类
class Zi extends Fu{
int num = 20 ;

public void show(){
System.out.println("show Zi...");
}

}

//测试类
public class DuoTaiDemo {
public static void main(String[] args) {
//创建父类的对象:多态的形式
// 有父类引用指向子类对象:向上转型
Fu f = new Zi() ;
//访问成变量
System.out.println(f.num);

//调用成员方法:show()
f.show() ;
}
}

这是个简单的多态实例，可以看出其中子类继承父类，并且重写父类的show()方法，在main()中，创建对象的时候，是将父类引用指向了子类对象，这就是上面说的多态的三个前提条件。这个程序运行的结果是10和show zi...。这就可以得出多态成员访问的特点：

当访问成员变量时（非静态的），编译看左，执行看左（就是只看向父类）

当访问成员方法时，编译看左，成员看右（方法重写）

多态的好处和弊端：

好处：1）提高了代码的维护性（存在继承）

             2)提高了代码的扩展性

弊端：不能访问子类特有的东西。就比如说是子类有一个自己特有的成员方法，不是继承父类的，那使用多态创建的对象是不能访问的。解决这个弊端使用的是向下转型。这里很容易就能想到我们前面说的向上转型，而确实在这里向下转型依赖于向上转型。向下转型指的是将父类引用强制转换为子类引用，格式为：子类名 对象=（子类名） 父类引用。

二、抽象类

抽象类，指的是那些抽象出来的，没有具体对象的类，有点类似于模板，就像是电子商品，他自己本身并不是一个具体的东西，只是一个从具体事物中抽象出来的概念，他的具体实现可以是电视，手机，但是自身并不能创建自己的对象。

抽象类不能实例化，用abstract定义。抽象类中可以定义抽象方法，也是用abstract定义，抽象方法没有方法体，只是一个方法声明。

那既然抽象类自己不能实例化，那要怎么使用它呢？这就是前面讲多态的目的了，在java中，多态更多的是使用在抽象类以及后面的接口。抽象类需要通过子类进行实例化，利用多态的形式。同样给出一个小的实例帮组理解：

abstract class Animal{

//抽象方法:没有方法体的一个方法
public abstract void eat() ;

public abstract void sleep() ;

//具体方法
/*public void eat(){
System.out.println("eat");
}*/

public void show(){
System.out.println("show Animal....");
}
}

//子类是具体类
class Cat extends Animal{

@Override
public void eat() {
System.out.println("猫吃鱼");
}

@Override
public void sleep() {
System.out.println("猫趴着睡觉..");
}

}

//测试类
public class AbstractDemo {
public static void main(String[] args) {
//当前Animal已经被abstract修饰了
// Animal a = new Animal();//Cannot instantiate the type Animal:抽象类不能实例化:instaceof

//多态:父类引用指向子类对象
Animal a = new Cat() ; //Animal是抽象类,---->抽象类多态形式
a.eat() ;
a.sleep() ;
}
}

从这个例子中还可以看出，抽象类中是可以有非抽象方法的，且抽象类也可以没有抽象方法。

三、接口

如果接触过C++，我们就会发现，对比C++的多继承来说，java只支持单继承，但是支持多层继承。这样的单继承使类的层次结构成树状结构，简化了程序结构，使类之间的关系相对简单。但是，单继承并不能很好的将复杂问题描述清楚，随着类的层次结构中深度的增加，其间接父类越多，继承的属性和方法也就越多，导致了子类数量庞大，难于管理和控制。为此java语言通过另一种机制实现了与类的多继承相似的功能，同时又避免了多继承的复杂性，这就是接口。

接口可以理解为一种扩展功能。比如人出生时本身都是不会敲代码的，一部分通过后面的训练所得到，就是一种扩展功能。

接口的命名和类一样，用到了interface关键字，interface  接口名{

}

同样，接口本身是不能实例化的，他也需要子类进行实例化。类与接口之间是一种实现关系，用implements关键字。同样给出小的实例帮组理解。

//跳高接口
public interface Jumping {
//抽象功能
public abstract void jump();（只有抽象方法）
}

这样就是定义了一个接口

public class JumpingCat  implements Jumping {

@Override
public void jump() {
System.out.println("猫可以跳高了...");
}
}

子类实现接口。

需要注意的是，接口中的成员变量被默认修饰符，static final修饰，所以其中的成员变量只能是常量。其中的成员方法被默认修饰符abstract修饰，都是抽象方法，所以不能有方法体，同时接口也不能有构造方法。

   

四、内部类

在一个类里面定义另外一个类，就叫做内部类。内部类分为成员内部类和局部内部类。

成员内部类，在外部类的成员位置定义。

访问方法：外部类名.内部类名   对象名=外部类对象.内部类对象

class Outer{
//外部类的成员变量
// public int num = 100 ;
private int num = 20 ;

//内部类
class Inner{
//内部类的成员方法
public void show(){
System.out.println(num);
}
}
}

局部内部类，定义在外部类的局部位置

class Outer5{
//外部类的成员变量
// public int num = 100 ;
private int num = 100 ;

//外部类的成员方法
public void method(){

//局部位置
class Inner5{
//局部内部类的成员方法
public void show(){
System.out.println(num);
}
}

Inner5 i = new Inner5() ;
i.show() ;
}
}

内部类是直接可以访问外部类的成员,包括私有，外部类想要访问内部类的成员,必须通过创建内部类的对象访问该内部类的成员。

匿名内部类：

是内部类的简化版格式。

 书写的格式:
  new 接口名或者类名(){
  方法重写;
   }
  
   匿名内部类的实质:
   继承了该类(抽象类)或者是实现了该接口的子类对象!

    interface Inter{
//抽象功能
public abstract void show() ;
public abstract void show2() ;
}

//外部类
class Outer6{
//成员方法
public void method(){

//使用接口名 对象名 = 匿名内部类的格式: new 接口名(){
//方法重写();
//}
Inter i = new Inter(){


@Override
public void show() {
System.out.println("show");
}


@Override
public void show2() {
System.out.println("show2");
}

};

//使用对象名调用
i.show();
i.show2() ;

}
}