08. Java基础&抽象类&内部类

1.抽象类

1.1 抽象类概述

​ 父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有 意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法 的类就是抽象类。

解释：

• 抽象方法：没有方法体的方法
• 抽象类：包含抽象方法的类

1.2 abstract使用

使用abstract关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，没有方法体。

定义格式：

修饰符 abstract 返回值类型 方法名 (参数列表)；

定义一个抽象类：

abstract class A{//定义一个抽象类
	
	public void fun(){//普通方法
		System.out.println("存在方法体的方法");
	}
	
	public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
	
}

1.3 抽象方法使用

​ 继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该父 类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。

代码示范：

class B extends A{//B类是抽象类的子类，是一个普通类

	@Override
	public void print() {//强制要求覆写
		System.out.println("Hello World !");
	}
	
}
public class TestDemo {

	public static void main(String[] args) {
		A a = new B();//向上转型
		
		a.print();//被子类所覆写的过的方法
	}
}

1.4 注意事项

1. 抽象类不能创建对象，如果创建，编译无法通过而报错，只能创建其非抽象子类的对象。

2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象

   类。

2. 内部类

2.1 内部类概述

​ 在一个类中定义一个类。例如在一个类A的内部定义一个类B，类B就被称为内部类。任何一个类都可以在内部定义一个或对个类，内部类本身就是类的一个属性。

内部类分为以下四种：

• 静态内部类：如：static class StaticClass{}；
• 成员内部类：如：private class InstanceClass{}；（普通内部类）
• 局部内部类：定义在方法或者表达式内部；
• 匿名内部类： 如：（new Thread(){}）.start()。

2.2 静态内部类

​ 一个类的静态成员独立于这个类的任何一个对象存在，在具有访问权限的地方，我们可以通过类名.静态成员名的形式来访问这个静态成员。

​ 静态内部类能作为一个外部类的静态成员而存在，创建一个类的静态内部类对象不需要依赖其外部类对象。

public class Demo{
    public DemoTest(){
        //创建静态内部类对象
        StaticClass sc=new StaticClass();
        
        System.out.println("静态内部类数据="+sc.number);
    }
    static class StaticClass{
        int number=1;
    }  
    public static void main(String[] args){
        Demo.StaticClass sc=new Demo.StaticClass();
    }
}

好处：

1. 作用域不会扩散到包外。
2. 可以通过“外部类.内部类”的方式直接访问。
3. 内部类可以访问外部类中的所有静态属性和方法。

2.3 成员内部类

在一个类里面作为类的一个字段直接定义就可以：

例如：

public class InnerClass{
    
    public class InnerClassA{
        
    }
}

成员内部类对象依赖外部类对象而存在——在创建一个成员内部类对象是首先要创建其外部类对象。

外界创建成员内部类格式：

格式： 外部类名.内部类名 对象名 = 外部类对象.内部类对象;

例如： Outer.Inner oi = new Outer().new Inner();

示例代码：

/* 
内部类访问特点： 
	内部类可以直接访问外部类的成员，包括私有 
	外部类要访问内部类的成员，必须创建对象 
*/
public class Outer { 
    private int num = 10; 
        
        public class Inner { 
            public void show() { 
                System.out.println(num);
            } 
        }
    
    public void method() { 
        Inner i = new Inner(); 
            i.show(); 
    } 
    
    public class InnerDemo {
        public static void main(String[] args) { 
            //Outer.Inner oi = new Outer().new Inner(); 
            //oi.show(); 
            Outer o = new Outer();
                o.method();
        } 
}

2.4 局部内部类

​ 局部内部类是在方法中定义的类。其声明在一个方法体 或 一段代码块的内部，而且不在定义类的定义域之内便无法使用，其提供的功能使用匿名内部类都可以实现，而本身匿名内部类可以写得比它更简洁，因此局部内部类用的比较少。

• 局部内部类定义位置

  局部内部类是在方法中定义的类

• 局部内部类方式方式

1. 局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用

2. 该类可以直接访问外部类的成员，也可以访问方法内的局部变量

示例代码：

class Outer {
    private int num = 10;

    public void method() {
        int num2 = 20;class Inner {
            public void show() {
                System.out.println(num);System.out.println(num2);
            }
        } 
        Inner i = new Inner();
        i.show();
    }
}

public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

​ 在局部内部类里面可以访问外部类对象的所有访问权限的字段，而外部类却不能访问局部内部类中定义的字段，因为局部内部类的定义只在其特定的方法体 / 代码块中有效，一旦出了这个定义域，那么其定义就失效了。

2.5 匿名内部类

• 匿名内部类的前提

  • 存在一个类或者接口，这里的类可以是具体类也可以是抽象类

• 匿名内部类的格式

  • 格式：new 类名 ( ) { 重写方法 } new 接口名 ( ) { 重写方法 }

  • 举例：

  new Inter(){
      @Override
      public void method(){} 
  }
  

• 匿名内部类的本质

  • 本质：是一个继承了该类或者实现了该接口的子类匿名对象

• 匿名内部类的细节

  • 匿名内部类可以通过多态的形式接受

  Inter i = new Inter(){
      @Override 
      public void method(){ 
      } 
  }
  

  示例代码：

  interface Inter {
      void method();
  }
  
  class Test {
      public static void main(String[] args) {
          new Inter() {
              @Override
              public void method() {
                  System.out.println("我是匿名内部类");}
          }.method(); // 直接调用方法 
        }
     }