Java内部类、泛型类和接口

快来打我* 2022-12-31 11:25 185阅读 0赞

### Java内部类、泛型类和接口 ###

本讲介绍Java面向对象的高级部分。对这一部分内容仅作必要而非深入的介绍。

**一、Java内部类**

在Java 语言中的类可以嵌套定义，允许在另外一个类中定义一个类，即在一个类的类体中可以嵌套（nested）定义另外一个类。外层的称为外部类（outer class），也可以叫做封闭类;内部的称为内部类（Inner Classes），有时也称为嵌套类(Nested Class)。内部类可以是静态(static)的，可以使用 public、protected 和 private 访问控制符，而外部类只能使用 public，或者默认。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70][]

例如：

class OuterClass \{

// code

class InnerClass \{

// code

Inner Classes 不能定义为static，不能有static方法和static初始化语句块。

内部类使用场景：当一个类只在某个类中使用，并且不允许除外部类外的其他类访问时，常用于GUI事件监听。

内部类的分类

☆成员式内部类

☆局部内部类

☆匿名内部类

有些人认为内部类的语法很复杂，实际开发中也较少用到，在此仅简要介绍。

**成员式内部类**

在外部类内部直接定义（不在方法内部或代码块内部）的类就是成员式内部类，它可以直接使用外部类的所有变量和方法，即使是 private 的。外部类要想访问内部类的成员变量和方法，则需要通过内部类的对象来获取。如：

public class Outer \{

private int size;

public class Inner \{

private int counter = 10;

public void doStuff() \{

size++;

public static void main(String args\[\]) \{

Outer outer = new Outer();

Inner inner = outer.new Inner();

inner.doStuff();

System.out.println(outer.size);

System.out.println(inner.counter);

// 下句编译错误，故注释掉，因为外部类不能访问内部类的变量

//System.out.println(counter);

输出：

注意：必须先有外部类的对象才能生成内部类的对象，因为内部类需要访问外部类中的成员变量，成员变量必须实例化才有意义。

成员式内部类如同外部类的一个普通成员。

成员式内部类可以使用各种修饰符，包括 public、protected、private、static、final 和 abstract，也可以不写。

若有 static 修饰符，就为类级，否则为对象级。类级可以通过外部类直接访问，对象级需要先生成外部的对象后才能访问。

非静态内部类中不能声明任何 static 成员。

内部类可以相互调用，例如：

class A \{

// B、C 间可以互相调用

class B \{\}

class C \{\}

**局部内部类**

局部内部类(Local class)是定义在代码块中的类。它们只在定义它们的代码块中是可见的。

局部类有几个重要特性：

仅在定义了它们的代码块中是可见的；

可以使用定义它们的代码块中的任何局部 final 变量；

局部类不可以是 static 的，里边也不能定义 static 成员；

局部类不可以用 public、private、protected 修饰，只能使用缺省的；

局部类可以是 abstract 的。

例子

public class OuterA \{

public static final int TOTAL\_NUMBER = 5;

public int id = 123;

public void func() \{

final int age = 15;

String str = "测试";

class Inner \{

public void innerTest() \{

System.out.println(TOTAL\_NUMBER);

System.out.println(id);

// System.out.println(str);不合法，只能访问本地方法的final变量

System.out.println(age);

new Inner().innerTest();

public static void main(String\[\] args) \{

OuterA OuterA = new OuterA();

OuterA.func();

运行结果：

123

**匿名内部类**

匿名内部类是局部内部类的一种特殊形式，也就是没有变量名指向这个类的实例，而且具体的类实现会写在这个内部类里面。

注意：匿名类必须继承一个父类或实现一个接口。

例子

abstract class PersonOne \{

public abstract void eat();

class Child extends PersonOne \{

public void eat() \{

System.out.println("eat something");

public class DemoOne \{

public static void main(String\[\] args) \{

PersonOne p = new Child();

p.eat();

运行结果：

eat something

**二、泛型类**

所谓“泛型”，就是“宽泛的数据类型”，任意的数据类型。

假如我们现在要定义一个类来表示坐标，要求坐标的数据类型可以是整数、小数和字符串，例如：

x = 10、y = 10

x = 12.88、y = 129.65

x = "东京180度"、y = "北纬210度"

针对不同的数据类型，除了借助方法重载，还可以借助自动装箱和向上转型。我们知道，基本数据类型可以自动装箱，被转换成对应的包装类；Object 是所有类的祖先类，任何一个类的实例都可以向上转型为 Object 类型，例如： int --> Integer --> Object

还可以使用泛型类。

泛型类声明格式为：

class 类名<泛型列表>

如：class A<E,F>

其中，A是泛型类的名称，E、F是泛型类的参数，即泛型类的参数类型没有指定。它可以是任何引用类型，但不能是基本数据类型。

例子

public class DemoGeneric \{

public static void main(String\[\] args)\{

// 实例化泛型类

PointOne<Integer, Integer> p1 = new PointOne<Integer, Integer>();

p1.setX(10);

p1.setY(20);

int x = p1.getX();

int y = p1.getY();

System.out.println("This Point is：" + x + ", " + y);

PointOne<Double, String> p2 = new PointOne<Double, String>();

p2.setX(25.4);

p2.setY("东京180度");

double m = p2.getX();

String n = p2.getY();

System.out.println("This Point is：" + m + ", " + n);

// 定义泛型类

class PointOne<T1, T2>\{

T1 x;

T2 y;

public T1 getX() \{

return x;

public void setX(T1 x) \{

this.x = x;

public T2 getY() \{

return y;

public void setY(T2 y) \{

this.y = y;

运行结果：

This point is：10, 20

This point is：25.4, 东京180度

上面的代码在类名后面多出了 <T1, T2>，T1, T2 是自定义的标识符，也是参数，用来传递数据的类型，而不是数据的值，我们称之为类型参数。在泛型中，不但数据的值可以通过参数传递，数据的类型也可以通过参数传递。T1, T2 只是数据类型的占位符，运行时会被替换为真正的数据类型。

传值参数（我们通常所说的参数）由小括号包围，如 (int x, double y)，类型参数（泛型参数）由尖括号包围，多个参数由逗号分隔，如 <T> 或 <T, E>。

类型参数需要在类名后面给出。一旦给出了类型参数，就可以在类中使用了。类型参数必须是一个合法的标识符，习惯上使用单个大写字母，通常情况下，K 表示键，V 表示值，E 表示异常或错误，T 表示一般意义上的数据类型。

泛型类在实例化时必须指出具体的类型，也就是向类型参数传值，格式为：

className variable<dataType1, dataType2> = new className<dataType1, dataType2>();

注意：

泛型是 Java 1.5 的新增特性，它以C++模板为参照，本质是参数化类型(Parameterized Type)的应用。

类型参数只能用来表示引用类型，不能用来表示基本类型，如  int、double、char 等。但是传递基本类型不会报错，因为它们会自动装箱成对应的包装类。

**三、Java接口(interface)**

接口（Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。

接口就是比“抽象类"还“抽象”的“抽象类”, 可以更加规范的对子类进行约束。全面地专业地实现了:规范和具体实现的分离。接口是完全面向规范的,规定了一批类具有的公共方法规范。

从接口的实现者角度看,接口定义了可以向外部提供的服务。

从接口的调用者角度看,接口定义了实现者能提供那些服务。

接口是两个模块之间通信的标准,通信的规范。如果能把你要设计的模块之间的接口定义好,就相当于完成了系统的设计大纲,剩下的就是添砖加瓦的具体实现了。大家在工作以后,做系统时往往就是使用“面向接口”的思想来设计系统。

接口和实现类不是父子关系,是实现规则的关系。

接口主要特点：

1、接口不能实例化对象 可以用来声明引用变量的类型

2、一个类实现一个接口，那么必须实现这个接口中定义的所有方法，并且只能是public

3、jdk1.7以及之前 接口中只能有方法的定义 jdk1.8之后可以有default（虚拟扩展方法）和静态方法

抽象类和接口的区别

<table> 
 <thead> 
 <tr> 
 <td style="border-color:#dddddd;"> 接口 </td> 
 <td style="border-color:#dddddd;"> 抽象类 </td> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td style="border-color:#dddddd;"> 不考虑java8中default方法的情况下，接口中是没有实现代码的实现 </td> 
 <td> 抽象类中可以有普通成员方法 ，并且可以定义变量 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#dddddd;"> 接口中的方法修饰符号 只能是public </td> 
 <td> 抽象类中的抽象方法可以有public,protected,default </td> 
 </tr> 
 <tr> 
 <td style="border-color:#dddddd;"> 接口中没有构造方法 </td> 
 <td> 可以有构造方法 </td> 
 </tr> 
 </tbody> 
</table>

接口和抽象类如何选择：

1、当我们需要一组规范的方法的时候，我们就可以用接口，在具体的业务中，来对接口进行实现，能达到以不变应对万变，多变的需求的情况我们只需要改变对应的实现类 。

2、如果多个实现类中有者相同可以复用的代码 这个时候就可以在实现类和接口之间，添加一个抽象类，把公共的代码抽出在抽象类中。然后要求不同实现过程的 子类可以重写抽象类中的方法，来完成各自的业务。

接口的定义（声明）语法格式如下：

\[访问修饰符号\] interface 接口名称 \[extends 父接口1\[，父接口2, ...\]\] \{

常量定义：

方法定义：

访问修饰符：只能是public 或者默认

extends：接口支持多继承

接口中的属性只能是常量，默认就是public static finnal

接口中的方法默认是public abstract

换句话说，接口有以下特性：

接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。

接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键子。

接口中的方法都是公有的。

一个接口，可以拥有N个直接的父接口，如：

interface A

…

interface B

…

interface C

…

//一个接口，可以拥有N个直接的父接口

public interface D extends A,B,C

…

接口的实现

当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。

使用implements关键字实现接口，接口实现的语法：

类修饰符 class 类名称 implements 接口名称1\[, 接口名称2, ...\] \{

...

下面给出一个例子，代码如下：

//用interface声明两个接口

interface Person \{

void say();

interface Parent \{

void work();

//用implements实现两个接口

class Child implements Person, Parent \{

public void work() \{

System.out.println("学习");

public void say() \{

System.out.println("Child");

public class TestImplements\{

public static void main(String\[\] args) \{

Child c = new Child();

c.say();

c.work();

运行输出结果：

Child

学习

下面再给出一个例子，代码如下：

//创建一个接口名字为Abc

interface Abc \{

//创建接口方法getMax

public int getMax();

//创建接口方法getMes

public String  getMes();

//test2类描述的是实现接口的方法

class test2 implements Abc\{

//实现接口里的方法

public int getMax()

//定义int类型的私有变量i

int i = 123;

//将变量i返回出去并退出方法

return i;

//实现接口里的方法

public String getMes()

//定义String类型的私有变量s

String s = "实现接口里的方法";

//将变量s返回出去并退出方法

return s;

public class TestImplements2\{

//main方法为Java程序的入口方法

public static void main(String args\[\])

//创建test类的对象实例,引用为t

test2 t = new test2();

//实现了接口里的方法并进行调用

int i = t.getMax();

String s = t.getMes();

//打印并显示结果

System.out.println(i);

System.out.println(s);

运行输出结果：

123

实现接口里的方法

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70]: /images/20221120/c72115ed4c84456fb2de9eecb42a77db.png