java中的内部类和多态

内部类

1. 定义
所谓内部类就是在一个类的内部进行其他类结构的嵌套的操作。通俗来说，可以类比人和心脏的关系。
2. 内部类的优点
a.内部类和外部类可以访问彼此的私有属性（内部类直接访问，外部类通过内部类对象间接访问）
例如：

class Outter{
  private String msg = "hello world!!";
  class Inner{
    void fun( ){
      System.out.println(msg);
      }
    }
   public void print( ){
     Inner in = new Inner( );
     in.fun( );
  }
  public class Ex{
  public static void main(String[ ] args){
    Outter out = new Outter( );
    out.print( );
  }

运行结果：

b.使用内部类可以实现多继承的概念
例如：

class A{ }
class B{ }
class C{
   class D extends class A{ }
   class E extends class B{ }
 }

c.内部类可以对外部类完全隐藏（保护性）
3. 内外部类的关系
a.成员内部类的创建需要依赖外部类对象，先有外部类对象而后才产生成员内部类对象。
b.内部类是一个相对独立的个体，与外部类不是is-a关系。
c.内部类可以直接访问外部类的元素，外部类需要通过内部类对象间接访问内部元素。

运行结果:

运行结果：

4.内部类的分类
依据—根据内部类的位置以及关键字一共分为以下四种内部类：
a.成员内部类（普通内部类）—类比普通属性
①.定义:直接定义在外部类中，不用static关键字修饰。
②.创建语法：外部类.内部类 内部类名称=new 外部类( ).new 内部类( );
** 注**：
成员内部类的限制：成员内部类可以访问外部类的静态属性，成员内部类不能拥有静态域。
b.静态内部类—类比静态属性/方法
①.定义：直接定义在外部类中，加static关键字修饰。
②.创建语法：外部类.内部类 内部类名称=new 外部类.内部类( );
** 注**：
静态内部类的限制： 静态内部类能拥有普通域，但是不能访问外部类的普通属性。

class Outter{
  private String msg = "hello world!!";
  static class Inner{
    public void fun( ){
      System.out.println(msg);
    }
  }
  public void print( ){
    Inner in = new Inner( );
    in.fun( );
}
public class Ex{
  public static void main(String[ ] args){
    Outter.Inner in = new Outter.Inner( );
    in.fun( );
 }
}

c.方法内部类
①.定义：方法内部类定义在外部类的方法中，方法内部类只能在该方法中被使用，出了该方法就失效。
②.使用方法内部类举例：

class Outter 
{    
    private int num;    
    public void display(int test) 
     {        
        class Inner  
        {            
        private void fun()  
        {                
           num++;                
           System.out.println(num);                
           System.out.println(test);   
            }     
          }       
         new Inner().fun();   
       } 
} 
public class Ex{    
    public static void main(String[] args) 
    {        
        Outter out = new Outter();        
        out.display(20);   
       } 
 }

运行结果：

d.匿名内部类
①.定义：匿名内部类其实就是一个没有名字的方法内部类，所以它符合方法内部类的所有约束.除此之外，还有一些地方需要注意:
1）匿名内部类是没有访问修饰符的。
2） 匿名内部类必须继承一个抽象类或者实现一个接口
3） 匿名内部类中不能存在任何静态成员或方法
4） 匿名内部类是没有构造方法的，因为它没有类名。
5）与局部内部相同匿名内部类也可以引用方法形参。此形参也必须声明为 final
②.匿名内部类举例：

interface MyInterface {    
    void test(); 
    } 
class Outter {    
    private int num;    
    public void display(int para) 
    {        // 匿名内部类，实现了MyInterface接口       
         new MyInterface(){
             public void test() 
             {                
                 System.out.println("匿名内部类"+para);           
               }        
             }
             .test();  
         } 
     }
 
public class Ex {   
    public static void main(String[] args) {        
        Outter outter = new Outter();        
        outter.display(20);   
      } 
 }

运行结果：

多态

1.定义：同一个类实例的相同方法在不同情形下的表现形式。
2.方法多态
a.方法重载：方法名称相同，参数个数以及类型不同，与返回值无关，无权限限制的方法。
b.方法覆写：子类写与父类方法名称、参数个数以及类型相同，具有权限的方法。子类不能有比父类强的权限。
3.对象多态
a.向上转型（90%情况下发生）
①.语法：父类 父类引用 = 子类实例( );
②.应用场景：参数统一化。
b.向下转型（1%）需要强转，发生向下转型之前，一定先发生向上转型。否则或抛出ClassCastException。
①.语法：子类 子类引用 = （子类）父类实例；
②.应用场景：发生在父类引用需要调用子类扩充的方法时，才发生向下转型变为子类引用调用其扩充方法。
**注：
无论是向上转型还是向下转型，本质在于发生了方法覆写。