当前位置：首页 > news >正文

JavaSE——类与对象（5）

news 2025/7/14 20:21:17

一、抽象类

1.1为什么需要抽象类

父类的某些方法，不确定怎么实现，也不需要实现。

class Animal{public String name;public Animal(String name){this.name = name;}public void eat()//这里实现了也没有意义{System.out.println("这是一个动物，但是不知道吃什么..");}
}

像上面这个例子，属于一个父类方法不确定性问题，可以考虑将这个方法设计为抽象方法。所谓的抽象方法就是没有实现的方法，没有实现的方法就是没有方法体，当一个类中存在抽象方法时，需要将这个类声明为抽象类。一般来讲，抽象类会被继承，由其子类来实现抽象方法。

1.2抽象类的细节

抽象类不能被实例化。
抽象类不一定要包含abstract方法，也就是说，抽象类可以没有abstract方法。
一旦类包含了abstract方法，那么这个类必须时abstract类。
abstract只能修饰类和方法，不能修饰属性和其它的。
抽象类可以拥有任意成员，抽象类的本质还是类。
如果一个类继承了抽象类，则它必须实现抽象类的所有方法，除非它自己也声明为抽象类。
抽象方法，不能使用private、final和static来修饰。

二、接口

2.1接口的基本介绍

接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，再根据具体情况把这些方法写出来。

定义的基本语法：

interface 接口名{属性方法
}

调用的基本语法：

class 类名 implements 接口{自己属性;自己方法;必须实现的接口的方法;
}

在JDK7以前，接口中的所有方法都是抽象方法，在JDK7以后的版本中，可以有静态方法和默认方法。另外接口不需要声明为抽象类。

2.2接口的使用细节

接口不能被实例化。
接口中的所有方法都是public方法，即使没有使用public修饰符，它也是public的。
接口中抽象方法，可以不用abstract修饰。
一个普通类上实现接口，必须将该接口的所有方法都实现。
抽象类实现接口，可以不用实现接口的方法。
一个类允许实现多个接口。
接口中的属性，只能是final的，而且默认是public static final修饰符。
接口中属性的访问形式：接口名.属性名。
一个接口不能继承其它类，但是可以继承多个别的接口。
接口的修饰符只能是public和默认。

2.3接口与继承

继承和接口解决的问题不同：
1. 继承的价值在于：解决代码的复用性和可维护性。
2. 接口的价值在于：设计好各种规范和方法，让其它类去实现这些方法。
接口比继承更加灵活，可以说是对Java单继承方式的一种补充，继承满足is-a关系，接口只需要满足like-a关系。
接口在一定程度上实现代码解耦。

2.4接口的多态特性

多态参数：接口引用可以指向实现了接口的类的对象。

public class Interface01{public static void main(String[] args) {IH ih = new A();IG ig = new A();}
}interface IH{}
interface IG{}class A implements IH{}

多态数组：多态性允许一个引用类型指向多种实际类型的对象。这种特性在处理数组时尤为有用，因为数组可以存储指向不同子类对象的引用，即使数组的声明类型是父类类型。

接口存在多态传递现象

public class Interface01{public static void main(String[] args) {IH ih = new A();IG ig = new A();}
}interface IH{}
interface IG{}
//interface IH extends IG{};A实现IH的同时把IG也实现了class A implements IH{}

三、内部类

3.1什么是内部类

一个类的内部完整的嵌套了另一个类结构，被嵌套的类称为内部类，嵌套其它类的类被称为外部类。一个内部类：

class Outer{//外部类private int i = 100;//属性public Outer(int n1){//构造器this.i = n1;}public void m1(){//方法System.out.println("m1()");}{//代码块System.out.println("代码块...");}class Inner{//内部类}
}

3.2内部类的分类

定义在外部类局部位置上（比如方法内）：

局部内部类（没有类名）
匿名内部类（没有类名）

定义在外部类的成员位置上：

成员内部类（未用static修饰）
静态内部类（使用static修饰）

3.3局部内部类

局部内部类定义在外部类的局部位置，比如方法中，并且有类名。

class Outer{//外部类private int i = 100;//属性public Outer(int n1){//构造器this.i = n1;}public void m1(){//方法System.out.println("m1()");}{//代码块System.out.println("代码块...");}public void m2(){class Inner{ //不能添加访问修饰符，因为它是一个局部变量，局部变量不能使用修饰符。//但是可以用final修饰public void m3(){System.out.println(i);//可以直接访问外部类的所有成员，包含私有的。}}Inner i = new Inner();//外部类访问内部类，先创建对象再访问，必须在作用域内。i.m3();}
}

总结：

内部类可以直接访问外部类的所有成员，包括私有的。
外部类访问内部类的成员需要先创建内部类的对象，再访问，并且必须在作用域内部。
作用域：仅仅在定义它的方法或者代码块中。
除final之外不能使用访问修饰符。
局部内部类本质是一个类也可以被继承。
如果外部类和内部类的成员重名，默认遵循就近原则，如果想要访问外部类的成员，使用外部类名.this.变量名。

3.4匿名内部类

匿名内部类是定义在外部类的局部位置，没有名字的类（其实有，只不过是由编译器取的，程序员看不见也不能干涉）。

假设我们有一个接口A，内部有一个未被实现的方法eat，如果想要在main中直接调用eat方法，按照传统思路是先用一个类来实现接口A，同时再创建B的对象来调用A。

public class Interface01 {public static void main(String[] args) {B b = new B();b.eat();}
}
interface A{public void eat();
}
class B implements A{@Overridepublic void eat() {System.out.println("正在调用eat方法");}
}

但是，如果这个方法只会实现一次，如果为此单独写一个类还要再创建对象的化，未免有些古板，这里就可以采用匿名内部类。

public class Interface01 {public static void main(String[] args) {new A(){@Overridepublic void eat() {System.out.println("正在调用eat方法");}}.eat();}
}
interface A{public void eat();
}

这是的匿名内部类相当于一个对象，所以它的后面可以直接调用eat方法。当A里面有多个方法时，如果想要同时调用，可以采用下面的方法。

public class Interface01 {public static void main(String[] args) {//编译器创建了一个类继承了A类，并且在内部重写了下面这些方法。//编译类型是A，运行类型是Interface01$1A a = new A(){@Overridepublic void eat() {System.out.println("正在调用eat方法");}public void drink(){System.out.println("正在调用drink方法");}};a.eat();a.drink();}
}
interface A{public void eat();public void drink();
}

匿名内部类常用做实参进行传递：

public class InnerClassExercise {public static void main(String[] args) {Cellphone cellphone = new Cellphone();cellphone.alarmlock(new Bell(){@Overridepublic void ring() {System.out.println("懒猪起床了");}});Bell innerclass = new Bell(){@Overridepublic void ring() {System.out.println("小伙伴上课了");}};cellphone.alarmlock(innerclass);}
}interface Bell{void ring();
}class Cellphone{public void alarmlock(Bell bell){bell.ring();}
}

总结：

匿名内部类本身既是一个类的定义，也是一个对象，所以从语法上看，它既有定义类的特征，也有创建对象的特征。
可以直接访问外部类的所有成员，包含私有的。
不能直接添加访问修饰符，因为他的地位就是一个局部变量。
作用域：仅仅再定义它的方法内部或者代码块中。
外部的其它类不能访问内部匿名类。
如果外部类和匿名内部类的成员重名，默认遵循就近原则，也可以通过（外部类名.this.成员名）去访问。

3.5成员内部类

成员内部类是定义再外部类的成员位置，并且没有static修饰。

public class MemberInnerClass01 {public static void main(String[] args) {Outer01 outer01 = new Outer01();outer01.t1();}
}class Outer01{private int a = 10;public String name = "张三";class InnerClass{public void say(){//可以直接访问外部类的成员System.out.println("Outer01的a = " + a + "\tOuter01的name + " + name);}}public void t1(){InnerClass innerClass = new InnerClass();innerClass.say();}
}

总结：

可以直接访问外部类的所有成员，包含私有的。
可以添加任意访问修饰符（public、protected、默认、private），因为它的地位是一个成员。
作用域：和外部域的其他成员一样，为整个类体比如前面案例。在外部类的成员方法中创建成员内部类对象，再调用方法。
成员内部类访问外部类成员：直接访问。
外部类访问成员内部类：先创建对象，再访问。

外部其它类访问成员内部类：

可以依托这样的语法：

OuterClass.InnerClass inner = OuterClass.new InnerClass()

在外部类中编写一个方法返回一个成员内部类的对象。

public class MemberInnerClass01 {public static void main(String[] args) {Outer01 outer01 = new Outer01();Outer01.InnerClass inner01 = outer01.new InnerClass();inner01.say();Outer01.InnerClass inner02 = outer01.getInnerClass();inner02.say();}
}class Outer01{private int a = 10;public String name = "张三";class InnerClass{int a = 20;public void say(){System.out.println("Outer01的a = " + a + "\tOuter01的name + " + name);}}public InnerClass getInnerClass(){return new InnerClass();}
}

3.6静态内部类

静态内部类定义在外部类的成员位置，并且有static修饰。

public class StaticInnerClass {public static void main(String[] args) {Outer outer = new Outer();//使用固定的语法Outer.Inner inner1 = new Outer.Inner();inner1.say();System.out.println("----------");//编写一个函数，返回静态内部类的对象实例Outer.Inner inner2 = outer.getInner();inner2.say();System.out.println("----------");//静态函数版本Outer.Inner inner3 = Outer.getInner_();inner3.say();}
}class Outer {private int n1 = 10;private static int n2 = 20;public static class Inner{//可以添加访问修饰符public void say(){//System.out.println(n1);//报错，不能访问非静态成员System.out.println(n2);//正确。}}public Inner getInner(){return new Inner();}public static Inner getInner_() {//静态版本return new Inner();}
}

总结：

可以直接访问外部类的所有静态成员，包含私有的，但是不能直接访问非静态成员。
可以添加任意访问修饰符，因为它的低位就是一个成员。
作用域：等同于其他成员，为整个类体。
静态内部类访问外部类：直接访问。
外部类访问静态内部类：创建对象在访问。
外部其它类访问静态内部类：
1. 使用语法进行访问：
```
Outer.Inner inner1 = new Outer.Inner();
```
2. 编写一个函数，返回内部类的一个对象。函数可以有static版本。
当与外部类成员重名时，采用外部类名.成员来访问。