一 .抽象类
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 用法
- Comparable 接口定义了 compareTo 方法，用于比较对象 。
- compareTo 方法判断这个对象相对于给定对象 o 的顺序，并且当这个对象小于、等于或大于给定对象 o 时，分别返回负整数、0或正整数。
- Comparable 接口是一个泛型接口。在实现该接口时，泛型类型 E 被替换成一种具体的类型。
- 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 { /** * @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字节码文件(也适用于局部内部类)
注意
- 非static的成员内部类中的成员不能声明为static的，只有在外部类或static的成员内部类中才可声明static成员。
- 外部类访问成员内部类的成员，需要“内部类.成员”或“内部类.对象.成员”的方式
- 成员内部类可以直接使用外部类的所有成员，包括私有的数据
- 当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的
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);//外部类的属性 } }} 复制代码输出结果：
作者：马走日lx
链接：https://juejin.im/post/6864894289751572493
4699
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
