Java基础——抽象类，接口和内部类（含JDK8接口新特性）

最新推荐文章于 2023-02-23 18:24:13 发布

马走日mazouri

最新推荐文章于 2023-02-23 18:24:13 发布

阅读量2.6k

点赞数 12

分类专栏： Java知识汇总文章标签：多态抽象类 java interface 接口

本文链接：https://blog.csdn.net/weixin_46215617/article/details/105470283

版权

Java知识汇总专栏收录该内容

12 篇文章 3 订阅

订阅专栏

一 .抽象类

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<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字节码文件（也适用于局部内部类）

注意

非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);//外部类的属性
		}
	}
}

输出结果：
在这里插入图片描述

马走日mazouri

关注

12
点赞
踩
22

收藏

觉得还不错? 一键收藏
打赏
4
评论
Java基础——抽象类，接口和内部类（含JDK8接口新特性）

目录一 .抽象类1. 介绍1.1基本用法1.2 抽象类的匿名子类2. 注意事项二. 接口1.介绍1.1 JDK7及以前用法1.2 JDK8用法2. Comparable接口2.1 用法2.2 注意事项3.Cloneable接口3.1 用法3.2 注意事项三. 内部类1. 介绍2.局部内部类3.匿名内部类4.静态内部类一 .抽象类1. 介绍1.1基本用法随着继承层次中一个个新子类的定义，类变...
复制链接

扫一扫