抽象类

抽象类的由来
父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了(因为子类对象会调用自己重写的方法)。换句话说，父类可能知道子类应该有哪个功能，但是功能具体怎么实现父类是不清楚的（由子类自己决定），父类只需要提供一个没有方法体的定义即可，具体实现交给子类自己去实现。我们把没有方法体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。

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

    abstract使用格式

    abstract是抽象的意思，用于修饰方法方法和类，修饰的方法是抽象方法，修饰的类是抽象类。
    抽象方法
    使用abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。
    1. 修饰符 abstract 返回值类型 方法名 (参数列表)；
    2. //代码举例：
    3. public abstract void run()；
    抽象类
    如果一个类包含抽象方法，那么该类必须是抽象类。注意：抽象类不一定有抽象方法，但是有抽象方法的类必须定义成抽象类。 ```java //代码举例：abstract class 类名字 {

} //代码举例： public abstract class Animal { public abstract void run()； }

  1. <a name="GOCWc"></a>
  2. ### 抽象类的使用
  3. **要求**：继承抽象类的子类**必须重写父类所有的抽象方法**。否则，该子类也必须声明为抽象类。
  4. ```java
  5. // 父类,抽象类
  6. abstract class Employee {
  7.     private String id;
  8.     private String name;
  9.     private double salary;
  11.     public Employee() {
  12.     }
  14.     public Employee(String id, String name, double salary) {
  15.         this.id = id;
  16.         this.name = name;
  17.         this.salary = salary;
  18.     }
  20.     // 抽象方法
  21.     // 抽象方法必须要放在抽象类中
  22.     abstract public void work();
  23. }
  25. // 定义一个子类继承抽象类
  26. class Manager extends Employee {
  27.     public Manager() {
  28.     }
  29.     public Manager(String id, String name, double salary) {
  30.         super(id, name, salary);
  31.     }
  32.     // 2.重写父类的抽象方法
  33.     @Override
  34.     public void work() {
  35.         System.out.println("管理其他人");
  36.     }
  37. }
  39. // 定义一个子类继承抽象类
  40. class Cook extends Employee {
  41.     public Cook() {
  42.     }
  43.     public Cook(String id, String name, double salary) {
  44.         super(id, name, salary);
  45.     }
  46.     @Override
  47.     public void work() {
  48.         System.out.println("厨师炒菜多加点盐...");
  49.     }
  50. }
  52. // 测试类
  53. public class Demo10 {
  54.     public static void main(String[] args) {
  55.         // 创建抽象类,抽象类不能创建对象
  56.         // 假设抽象类让我们创建对象,里面的抽象方法没有方法体,无法执行.所以不让我们创建对象
  57. //        Employee e = new Employee();
  58. //        e.work();
  60.         // 3.创建子类
  61.         Manager m = new Manager();
  62.         m.work();
  64.         Cook c = new Cook("ap002", "库克", 1);
  65.         c.work();
  66.     }
  67. }

此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

抽象类的细节

不需要背，只要当idea报错之后，知道如何修改即可。
关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。

  1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
    • 理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
  2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
    • 理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。
  3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
    • 理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。
  4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则子类也必须定义成抽象类，编译无法通过而报错。
    • 理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。
  5. 抽象类存在的意义是为了被子类继承。
    • 理解：抽象类中已经实现的是模板中确定的成员，抽象类不确定如何实现的定义成抽象方法，交给具体的子类去实现。

抽象类存在的意义
降低接口实现类在开发过程中实现接口的难度，同时将接口实现类不需要的方法交给抽象类完成。

接口

接口概念

接口中的只有包含：抽象方法和常量
接口中的抽象方法的public abstract可以省略。 接口中常量的public static final 可以省略。

  1. public interface InterF {
  2.     // 抽象方法！
  3.     //    public abstract void run();
  4.     void run();
  6.     //    public abstract String getName();
  7.     String getName();
  9.     //    public abstract int add(int a , int b);
  10.     int add(int a , int b);
  13.     // 它的最终写法是：
  14.     // public static final int AGE = 12 ;
  15.     int AGE  = 12; //常量
  16.     String SCHOOL_NAME = "黑马程序员";
  18. }
  1. /**接口的实现：
  2.     在Java中接口是被实现的，实现接口的类称为实现类。
  3.     实现类的格式:*/
  4. class 类名 implements 接口1,接口2,接口3...{
  6. }

接口在开发中的作用

  1. public interface FoodMeau{
  2.      void xihongshi();
  3.     void qiezi();
  4. }
  1. public class ChinaCook implements FoodMeau{
  2.     public void xihongshi(){
  3.         System.out.println("中国西红柿");
  4.     }
  6.     public void qiezi(){
  7.         System.out.println("中国茄子");
  8.     }
  9. }
  1. public class AmericCook implements FoodMeau {
  2.     public void xihongshi(){
  3.         System.out.println("美国西红柿");
  4.     }
  5.     public void qiezi(){
  6.         System.out.println("美国茄子");
  7.     }
  8. }
  1. public class Customer {
  2.    private FoodMeau foodMeau;
  4.    public Customer(){
  6.    }
  7.    public Customer(FoodMeau foodMeau){
  8.        this.foodMeau=foodMeau;
  9.    }
  10.    public void setFoodMeau( FoodMeau foodMeau){
  11.        this.foodMeau=foodMeau;
  12.    }
  13.    public FoodMeau getFoodMeau(){
  14.        return foodMeau;
  15.    }
  16.    public void order(){
  17.        foodMeau.xihongshi();
  18.        foodMeau.qiezi();
  19.    }
  20. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         //创建厨师对象
  4.         FoodMeau cook1 = new ChinaCook();
  5.         //创建顾客对象
  6.         Customer customer = new Customer(cook1);;//如果去掉参数，则空指针异常 
  7.         customer.order();//中国西红柿
  8.                         //中国茄子
  9.     }
  10. }

抽象类与接口的比较

比较
相同点:
接口和抽象类都不能实例化。
都包含抽象方法,其子类都必须重写这些抽象方法

不同点:

类型 抽象类 接口
继承 抽象类可以继承一个类，但可以实现多个接口。 接口只可继承接口(一个或多个)
成员变量 任何类型 只能是public static final
方法 任意的修饰符 默认使用public修饰符
构造器 可以有构造器 不能有构造器

内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。可以把内部类理解成寄生，外部类理解成宿主。
内部类的分类
按定义的位置来分

  1. 成员内部内，类定义在了成员位置 (类中方法外称为成员位置，无static修饰的内部类)
  2. 静态内部类，类定义在了成员位置 (类中方法外称为成员位置，有static修饰的内部类)
  3. 局部内部类，类定义在方法内
  4. 匿名内部类，没有名字的内部类，可以在方法中，也可以在类中方法外。

    成员内部类

    成员内部类特点：
  • 无static修饰的内部类，属于外部类对象的。
  • 宿主：外部类对象。

内部类的使用格式：
外部类.内部类。 // 访问内部类的类型都是用 外部类.内部类
获取成员内部类对象的两种方式：
方式一：外部直接创建成员内部类的对象
外部类.内部类 变量 = new 外部类（）.new 内部类（）;
方式二：在外部类中定义一个方法提供内部类的对象
案例演示

  1. 方式一：
  2. public class Test {
  3.     public static void main(String[] args) {
  4.         //  宿主：外部类对象。
  5.         // Outer out = new Outer();
  6.         // 创建内部类对象。
  7.         Outer.Inner oi = new Outer().new Inner();
  8.         oi.method();
  9.     }
  10. }
  12. class Outer {
  13.     // 成员内部类，属于外部类对象的。
  14.     // 拓展：成员内部类不能定义静态成员。
  15.     public class Inner{
  16.         // 这里面的东西与类是完全一样的。
  17.         public void method(){
  18.             System.out.println("内部类中的方法被调用了");
  19.         }
  20.     }
  21. }
  24. 方式二：
  25. public class Outer {
  26.     String name;
  27.     private class Inner{
  28.         static int a = 10;
  29.     }
  30.     public Inner getInstance(){
  31.         return new Inner();
  32.     }
  33. }
  35. public class Test {
  36.     public static void main(String[] args) {
  37.         Outer o = new Outer();
  38.         System.out.println(o.getInstance());
  39.     }
  40. }

成员内部类的细节

编写成员内部类的注意点：

  1. 成员内部类可以被一些修饰符所修饰，比如： private，默认，protected，public，static等
  2. 在成员内部类里面，JDK16之前不能定义静态变量，JDK16开始才可以定义静态变量。
  3. 创建内部类对象时，对象中有一个隐含的Outer.this记录外部类对象的地址值。（请参见3.6节的内存图）

详解：
内部类被private修饰，外界无法直接获取内部类的对象，只能通过方式二获取内部类的对象
被其他权限修饰符修饰的内部类一般用方式一直接获取内部类的对象
内部类被static修饰是成员内部类中的特殊情况，叫做静态内部类下面单独学习。
内部类如果想要访问外部类的成员变量，外部类的变量必须用final修饰，JDK8以前必须手动写final，JDK8之后不需要手动写，JDK默认加上。

成员内部类面试题

请在?地方向上相应代码,以达到输出的内容
注意：内部类访问外部类对象的格式是：外部类名.this

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Outer.inner oi = new Outer().new inner();
  4.         oi.method();
  5.     }
  6. }
  8. class Outer {   // 外部类
  9.     private int a = 30;
  11.     // 在成员位置定义一个类
  12.     class inner {
  13.         private int a = 20;
  15.         public void method() {
  16.             int a = 10;
  17.             System.out.println(???);    // 10   答案：a
  18.             System.out.println(???);    // 20   答案：this.a
  19.             System.out.println(???);    // 30   答案：Outer.this.a
  20.         }
  21.     }
  22. }

成员内部类内存图

内部类内存图.png

静态内部类

静态内部类特点：

  • 静态内部类是一种特殊的成员内部类。
  • 有static修饰，属于外部类本身的。
  • 总结：静态内部类与其他类的用法完全一样。只是访问的时候需要加上外部类.内部类。
  • 拓展1:静态内部类可以直接访问外部类的静态成员。
  • 拓展2:静态内部类不可以直接访问外部类的非静态成员，如果要访问需要创建外部类的对象。
  • 拓展3:静态内部类中没有银行的Outer.this。

内部类的使用格式：
外部类.内部类。
静态内部类对象的创建格式：
外部类.内部类 变量 = new 外部类.内部类构造器;
调用方法的格式：

  • 调用非静态方法的格式：先创建对象，用对象调用
  • 调用静态方法的格式：外部类名.内部类名.方法名();

案例演示：

  1. // 外部类：Outer01
  2. class Outer01{
  3.     private static  String sc_name = "黑马程序";
  4.     // 内部类: Inner01
  5.     public static class Inner01{
  6.         // 这里面的东西与类是完全一样的。
  7.         private String name;
  8.         public Inner01(String name) {
  9.             this.name = name;
  10.         }
  11.         public void showName(){
  12.             System.out.println(this.name);
  13.             // 拓展:静态内部类可以直接访问外部类的静态成员。
  14.             System.out.println(sc_name);
  15.         }
  16.     }
  17. }
  19. public class InnerClassDemo01 {
  20.     public static void main(String[] args) {
  21.         // 创建静态内部类对象。
  22.         // 外部类.内部类  变量 = new  外部类.内部类构造器;
  23.         Outer01.Inner01 in  = new Outer01.Inner01("张三");
  24.         in.showName();
  25.     }
  26. }

局部内部类

  • 局部内部类 ：定义在方法中的类。

定义格式:

  1. class 外部类名 {
  2.     数据类型 变量名;
  4.     修饰符 返回值类型 方法名(参数列表) {
  5.         // …
  6.         class 内部类 {
  7.             // 成员变量
  8.             // 成员方法
  9.         }
  10.     }
  11. }

匿名内部类【重点】

概述
匿名内部类 ：是内部类的简化写法。他是一个隐含了名字的内部类。开发中，最常用到的内部类就是匿名内部类了。
格式

  1. new 类名或者接口名() {
  2.     重写方法;
  3. };

包含了：

  • 继承或者实现关系
  • 方法重写
  • 创建对象

所以从语法上来讲，这个整体其实是匿名内部类对象

什么时候用到匿名内部类

实际上，如果我们希望定义一个只要使用一次的类，就可考虑使用匿名内部类。匿名内部类的本质作用
是为了简化代码。
之前我们使用接口时，似乎得做如下几步操作：

  1. 定义子类
  2. 重写接口中的方法
  3. 创建子类对象
  4. 调用重写后的方法 ```java interface Swim { public abstract void swimming(); }

// 1. 定义接口的实现类 class Student implements Swim { // 2. 重写抽象方法 @Override public void swimming() { System.out.println(“狗刨式…”); } }

public class Test { public static void main(String[] args) { // 3. 创建实现类对象 Student s = new Student(); // 4. 调用方法 s.swimming(); } }

  1. 我们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是做这样的快捷方式。
  2. <a name="jtP29"></a>
  3. #### 匿名内部类前提和格式
  4. 匿名内部类必须**继承一个父类**或者**实现一个父接口**。<br />**匿名内部类格式**
  5. ```java
  6. new 父类名或者接口名(){
  7.     // 方法重写
  8.     @Override 
  9.     public void method() {
  10.         // 执行语句
  11.     }
  12. };

使用方式

以接口为例，匿名内部类的使用，代码如下：

  1. interface Swim {
  2.     public abstract void swimming();
  3. }
  5. public class Demo07 {
  6.     public static void main(String[] args) {
  7.         // 使用匿名内部类
  8.         new Swim() {
  9.             @Override
  10.             public void swimming() {
  11.                 System.out.println("自由泳...");
  12.             }
  13.         }.swimming();
  15.         // 接口 变量 = new 实现类(); // 多态,走子类的重写方法
  16.         Swim s2 = new Swim() {
  17.             @Override
  18.             public void swimming() {
  19.                 System.out.println("蛙泳...");
  20.             }
  21.         };
  23.         s2.swimming();
  24.         s2.swimming();
  25.     }
  26. }

匿名内部类的特点

  1. 定义一个没有名字的内部类
  2. 这个类实现了父类，或者父类接口
  3. 匿名内部类会创建这个没有名字的类的对象

    匿名内部类的使用场景

    通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。代码如下： ```java interface Swim { public abstract void swimming(); }

public class Demo07 { public static void main(String[] args) { // 普通方式传入对象 // 创建实现类对象 Student s = new Student();

  1.     goSwimming(s);
  2.     // 匿名内部类使用场景:作为方法参数传递
  3.     Swim s3 = new Swim() {
  4.         @Override
  5.         public void swimming() {
  6.             System.out.println("蝶泳...");
  7.         }
  8.     };
  9.     // 传入匿名内部类
  10.     goSwimming(s3);
  12.     // 完美方案: 一步到位
  13.     goSwimming(new Swim() {
  14.         public void swimming() {
  15.             System.out.println("大学生, 蛙泳...");
  16.         }
  17.     });
  19.     goSwimming(new Swim() {
  20.         public void swimming() {
  21.             System.out.println("小学生, 自由泳...");
  22.         }
  23.     });
  24. }
  26. // 定义一个方法,模拟请一些人去游泳
  27. public static void goSwimming(Swim s) {
  28.     s.swimming();
  29. }

} ```