一 .抽象类

1. 介绍

1.1基本用法

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。

• 用abstract关键字来修饰一个类，这个类叫做抽象类。
  比如：abstract class A{ }

• 用abstract来修饰一个方法，该方法叫做抽象方法。

  • 抽象方法：只有方法的声明，没有方法的实现。以分号结束：比如：public abstract void talk();

1.2 抽象类的匿名子类

以下代码中的Person类是一个抽象类

① 非匿名的类非匿名的对象

  Worker worker = new Worker(); method1(worker);//非匿名的类非匿名的对象 

② 非匿名的类匿名的对象

method1(new Worker()); 

③ 匿名子类的对象

            Person p = new Person(){//Person是一个抽象类，不能实例化，这儿运用了多态的性质 @Override public void eat() {     System.out.println("吃东西"); } }; method1(p); 

④ 匿名子类的匿名对象

method1(new Person(){ @Override public void eat() {     System.out.println("吃好吃东西"); } }); 

2. 注意事项

• 抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
• 抽象方法不能包含在非抽象类中。如果抽象父类的子类不能实现所有的抽象方法，那么子类也必须定义为抽象的。换句话说，在抽象类扩展的非抽象子类中，必须实现所有的抽象方法。还要注意到，抽象方法是非静态的。
• 不能用abstract修饰变量、代码块、构造器。
• 不能用abstract修饰私有方法、静态方法、final的方法、final的类。但是可以有静态方法，静态方法的好处是不实例化就可由抽象类或子类类名直接调用
• 可以定义一个抽象类的对象变量，但是他只能引用非抽象类的对象。 如下代码，这里的p是一个抽象类Person的变量，Person引用了一个非抽象子类Student的实例。

Person p = new Student("John"); 

• 即使子类的父类是具体的，这个子类也可以是抽象的。

• 不能使用 new 操作符从一个抽象类创建一个实例，但是抽象类可以用作一种数据类
  型。因此，下面的语句创建一个元素是 CeometricObject 类型的数组是正确的：

GeometricObject[] objects = new CeometricObject[10]; 

    然后可以创建一个 CeometricObject 的实例，并将它的引用陚值给数组，如下所示：  

objects[0] =new Circle（）; 

关于构造器与静态方法的代码如下：

abstract class AbstractClass{ /**      * 输出      */ abstract void print(); /**      *      */ public AbstractClass() {//抽象类中可以定义构造器，虽然不能初始化，可以被子类继承         System.out.println("abstract class"); } public static void staticAbstractMethod() {         System.out.println("I am static method"); } } /**  * @author sir  */ public class AbstractClassTest extends AbstractClass{ public AbstractClassTest() {         System.out.println("子类构造器"); } @Override void print() {         System.out.println("test"); } public static void main(String[] args) {         AbstractClassTest.staticAbstractMethod();//抽象类中可以定义静态方法，可直接由类名调用         AbstractClass.staticAbstractMethod(); new AbstractClassTest().print(); } } 

输出结果：

二. 接口

1.介绍

1.1 基本用法

接口是一种与类相似的结构，它在许多方面都与抽象类很相似，但是它的目的是指明相关或者不相关类的多个对象的共同行为。接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。继承是一个”是不是”的关系，而接口实现则是 “能不能”的关系。
语法：

修饰符 interface 接口名 { /** 常量声明 */ /** 方法签名 */ } 

定义Java类的语法格式：先写extends，后写implements

 class SubClass extends SuperClass implements InterfaceA{ } 

• 接口中不能定义构造器的！意味着接口不可以实例化。
• Java开发中，接口通过让类去实现(implements)的方式来使用。类和接口之间的关系称为接口继承（ interface inheritance)。因为接口继承和类继承本质上是相同的，所以我们将它们都简称为继承。如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化。如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类。
• Java类可以实现多个接口，弥补了Java单继承性的局限性
  格式：class AA extends BB implements CC,DD,EE
• 接口与接口之间可以继承，而且可以多继承

1.2接口和抽象类之间的对比

接口示例：

public class USBTest { public static void main(String[] args) {          Computer computer = new Computer(); //1.创建了接口的非匿名实现类的非匿名对象         Flash flash = new Flash();         computer.transferData(flash); //2. 创建了接口的非匿名实现类的匿名对象         computer.transferData(new Printer()); //3. 创建了接口的匿名实现类的非匿名对象         USB phone = new USB(){ @Override public void start() {                 System.out.println("手机开始工作"); } @Override public void stop() {                 System.out.println("手机结束工作"); } };         computer.transferData(phone); //4. 创建了接口的匿名实现类的匿名对象          computer.transferData(new USB(){ @Override public void start() {                 System.out.println("mp3开始工作"); } @Override public void stop() {                 System.out.println("mp3结束工作"); } }); } } class Computer{ public void transferData(USB usb){//USB usb = new Flash();         usb.start();          System.out.println("具体传输数据的细节");          usb.stop(); } } interface USB{ //常量：定义了长、宽、最大最小的传输速度等 void start(); void stop(); } class Flash implements USB{ @Override public void start() {         System.out.println("U盘开启工作"); } @Override public void stop() {         System.out.println("U盘结束工作"); } } class Printer implements USB{ @Override public void start() {         System.out.println("打印机开启工作"); } @Override public void stop() {         System.out.println("打印机结束工作"); } } 

1.3JDK8接口新特性

除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法
Java 8中，你可以为接口添加静态方法和默认方法。从技术角度来说，这是完全合法的，只是它看起来违反了接口作为一个抽象定义的理念。

• 静态方法：使用 static 关键字修饰。可以通过接口直接调用静态方法，并执行其方法体。 我们经常在相互一起使用的类中使用静态方法。你可以在标准库中找到像Collection/Collections或者Path/Paths这样成对的接口和类。
• 默认方法：默认方法使用 default 关键字修饰。可以通过实现类对象来调用。 我们在已有的接口中提供新方法的同时，还保持了与旧版本代码的兼容性。比如：java 8 API中对Collection、List、Comparator等接口提供了丰富的默认方法。
• 若一个接口中定义了一个默认方法，而另外一个接口中也定义了一个同名同参数的方法（不管此方法是否是默认方法），在实现类同时实现了这两个接口时，会出现：接口冲突。
  • 解决办法：实现类必须覆盖接口中同名同参数的方法，来解决冲突。
• 若一个接口中定义了一个默认方法，而父类中也定义了一个同名同参数的非抽象方法，则不会出现冲突问题。因为此时遵守：类优先原则。接口中具有相同名称和参数的默认方法会被忽略

public interface CompareA { //静态方法 public static void method1(){   System.out.println("CompareA:北京"); } //默认方法 public default void method2(){   System.out.println("CompareA：上海"); } default void method3(){   System.out.println("CompareA：上海"); } } ********************************************** public interface CompareB { default void method3(){   System.out.println("CompareB：上海"); } } public class SuperClass { public void method3(){   System.out.println("SuperClass:北京"); } } ********************************************** public class SubClassTest { public static void main(String[] args) {   SubClass s = new SubClass(); //  s.method1(); //  SubClass.method1(); //知识点1：接口中定义的静态方法，只能通过接口来调用。   CompareA.method1(); //知识点2：通过实现类的对象，可以调用接口中的默认方法。 //如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法   s.method2(); //知识点3：如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法， //那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。-->类优先原则 //知识点4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法， //那么在实现类没有重写此方法的情况下，报错。-->接口冲突。 //这就需要我们必须在实现类中重写此方法   s.method3(); } } ************************************************************* class SubClass extends SuperClass implements CompareA,CompareB{ public void method2(){   System.out.println("SubClass：上海"); } public void method3(){   System.out.println("SubClass：深圳"); } //知识点5：如何在子类(或实现类)的方法中调用父类、接口中被重写的方法 public void myMethod(){ method3();//调用自己定义的重写的方法 super.method3();//调用的是父类中声明的 //调用接口中的默认方法   CompareA.super.method3();   CompareB.super.method3(); } } 

输出结果：

2. Comparable接口

2.1 用法

1. Comparable 接口定义了 compareTo 方法，用于比较对象 。
2. compareTo 方法判断这个对象相对于给定对象 o 的顺序，并且当这个对象小于、等于或大于给定对象 o 时，分别返回负整数、0或正整数。
3. Comparable 接口是一个泛型接口。在实现该接口时，泛型类型 E 被替换成一种具体的类型。
4. Java 类库中的许多类实现了 Comparable 接口以定义对象的自然顺序。Byte、Short、Integer、Long、Float、Double、Character、Biglnteger、BigDecimalx Calendar、String以及 Date 类 都 实 现 了 Comparable 接 口。

import java.util.Date; /**  * @author mazouri  * @create 2020-04-12 17:40  */ public class CompareTest { public static void main(String[] args) {         System.out.println((new Integer(3).compareTo(new Integer(5)))); // System.out.println((Integer.compare(3, 5)));当然可以用这个更好的方法         System.out.println("ABC".compareTo("ABE"));         Date date1 = new Date(1990, 1, 1);         Date date2 = new Date(1989, 6, 4);         System.out.println(date1.compareTo(date2)); } } 

输出结果：

2.2 自定义实现Comparable的类进行比较

题目：
定义一个接口用来实现两个对象的比较。 interface CompareObject{ public int
compareTo(Object o);
//若返回值是 0 , 代表相等; 若为正数，代表当 前对象大；负数代表当前对象小 }
定义一个Circle类，声明width，height属性，提供getter和setter方法
定义一个ComparableRectangle.类，继承Rectangle类并且实现CompareObject接口。在
ComparableCircle类中给出接口中方法compareTo的实现体，用来比较两个长方形面积大小。
定义一个测试类ComparableRectangleTest，创建两个ComparableRectangle对象，调用compareTo 方法比较两个类的面积大小。

public interface CompareObject<C extends Rectangle> { /**      * @return 若返回值是 0 , 代表相等; 若为正数，代表当前对象大；负数代表当前对象小      */ int compareTo(Object o); } ****************************************************************** public class Rectangle { private double width; private double height; public Rectangle() { } public Rectangle(double width, double height) { this.width = width; this.height = height; } public double getWidth() { return width; } public void setWidth(double width) { this.width = width; } public double getHeight() { return height; } public void setHeight(double height) { this.height = height; } public double getArea() { return height * width; } } ****************************************************************** public class ComparableRectangle extends Rectangle implements CompareObject { public ComparableRectangle() { } public ComparableRectangle(double width, double height) { super(width, height); } @Override public int compareTo(Object o) { if (this == o) { return 0; } if (o instanceof ComparableRectangle) {             ComparableRectangle c = (ComparableRectangle) o; // return Double.compare(getArea(), c.getArea()); if (getArea() > c.getArea()) { return 1; } else if (getArea() < c.getArea()) { return -1; } else { return 0; } } else { throw new RuntimeException("传入的数据类型不匹配"); } } } ****************************************************************** public class ComparableRectangleTest { public static void main(String[] args) {         ComparableRectangle c1 = new ComparableRectangle(2.2, 3.4);         ComparableRectangle c2 = new ComparableRectangle(2.3, 3.4); int compareValue = c1.compareTo(c2); if (compareValue > 0) {             System.out.println("c1对象大"); } else if (compareValue < 0) {             System.out.println("c2对象大"); } else {             System.out.println("c1与c2一样大"); } } } 

输出结果：

三. 内部类

1. 介绍

• 当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。
• 在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。

分类：
① 成员内部类（static成员内部类和非static成员内部类）
② 局部内部类（不谈修饰符）、匿名内部类

2.局部内部类

2.1 基本用法

java局部内部类就是在方法中定义的类，它仅在该方法中有效。

class 外部类{ 方法(){      class 局部内部类{       }   }   {      class 局部内部类{       }     }   } 

2.2 如何使用局部内部类：

• 只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类
• 但是它的对象可以通过外部方法的返回值返回使用，返回值类型只能是局部内部类的父类或父接口类型

2.3 局部内部类的特点

• 内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号，以及数字编号。
• 只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类。
• 局部内部类可以使用外部类的成员，包括私有的。
• 局部内部类可以使用外部方法的局部变量，但是必须是final的。 由局部内部类和局部变量的声明周期不同所致。
  • jdk 7及之前版本：要求此局部变量显式的声明为final的
  • jdk 8及之后的版本：可以省略final的声明
• 局部内部类和局部变量地位类似，不能使用public,protected,缺省,private
• 局部内部类不能使用static修饰，因此也不能包含静态成员

3.匿名内部类

3.1 基本用法

匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
格式：

new 父类构造器（实参列表）实现接口(){ //匿名内部类的类体部分 } 

interface A{ public abstract void fun1(); } public class Outer{ public static void main(String[] args) { new Outer().callInner(new A(){ //接口是不能new但此处比较特殊是子类对象实现接口，只不过没有为对象取名 public void fun1() { System.out.println(“implement for fun1"); } });// 两步写成一步了 } public void callInner(A a) { a.fun1(); } } 

3.2匿名内部类的特点

• 匿名内部类必须继承父类或实现接口
• 匿名内部类只能有一个对象
• 匿名内部类对象只能使用多态形式引用

4.成员内部类

4.1 成员内部类作为类的成员的角色：

• 和外部类不同，Inner class还可以声明为private或protected；
• 可以调用外部类的结构
• Inner class 可以声明为static的，但此时就不能再使用外层类的非static的成员变量；

4.2 成员内部类作为类的角色：

• 可以在内部定义属性、方法、构造器等结构
• 可以声明为abstract类 ，因此可以被其它的内部类继承
• 可以声明为final
• 编译以后生成OuterClass$InnerClass.class字节码文件（也适用于局部内部类）

注意

1. 非static的成员内部类中的成员不能声明为static的，只有在外部类或static的成员内部类中才可声明static成员。
2. 外部类访问成员内部类的成员，需要“内部类.成员”或“内部类.对象.成员”的方式
3. 成员内部类可以直接使用外部类的所有成员，包括私有的数据
4. 当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的

public class InnerClassTest { public static void main(String[] args) { //创建Dog实例(静态的成员内部类):   Person.Dog dog = new Person.Dog();   dog.show(); //创建Bird实例(非静态的成员内部类): //  Person.Bird bird = new Person.Bird();//错误的   Person p = new Person();   Person.Bird bird = p.new Bird();   bird.sing();      System.out.println();      bird.display("黄鹂"); } } class Person{    String name = "小明"; int age; public void eat(){   System.out.println("人：吃饭"); } //静态成员内部类 static class Dog{   String name; int age; public void show(){    System.out.println("卡拉是条狗"); //   eat(); } } //非静态成员内部类 class Bird{   String name = "杜鹃"; public Bird(){ } public void sing(){    System.out.println("我是一只小小鸟");    Person.this.eat();//调用外部类的非静态属性 eat();    System.out.println(age); } public void display(String name){    System.out.println(name);//方法的形参    System.out.println(this.name);//内部类的属性    System.out.println(Person.this.name);//外部类的属性 } } } 

输出结果：