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

Java学习day_12之面向对象进阶（抽象类接口内部类）

news 2025/8/16 12:47:51

一、抽象类与抽象方法

抽象方法：将共性的行为（方法）抽取到父类之后。由于每一个子类执行的内容是不一样的，所以在父类中不能确定具体的方法体，该方法就可以定义为抽象方法。
抽象类：如果一个类中存在抽象方法，那么这个类就必须声明为抽象类

抽象类与抽象方法的定义格式

  • 抽象方法的定义格式：

    public abstract 返回值类型 方法名(参数列表);

  • 抽象类的定义格式：

    public abstract class 类名{}

抽象类与抽象方法的注意事项

  • 抽象类不能实例化（创建对象）
  • 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
  • 可以有构造方法
  • 抽象类的子类:
    要么重写抽象类的所有抽象方法
    要么是抽象类

代码示例：

public abstract class Animal {private String name;private int age;public Animal() {}public Animal(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public void drink(){System.out.println("喝水");}public abstract void eat();}

public class Frog extends Animal{public Frog() {}public Frog(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println("青蛙在吃虫子");}
}

public class Test {public static void main(String[] args) {Frog f = new Frog("小绿",1);System.out.println(f.getName() + ", " + f.getAge());f.eat();f.drink();}
}

在这里插入图片描述

二、接口

在Java中，接口是一种完全抽象的类，用于定义一组方法签名（无具体实现），以及常量（public static final变量），用于规范类必须实现的行为，实现多态和解耦。

1.接口的定义与使用

  • 接口用关键字interface来定义：public interface 接口名{}
  • 接口不能实例化
  • 接口和类之间是实现关系，通过implements关键字表示
    public class 类名 implements 接口名{}
  • 接口的子类（实现类）
    要么重写接口中的所有抽象方法
    要么是抽象类
    注意
    1.接口和类的实现关系，可以单实现，也可以多实现
    public class 类名 implements 接口名1，接口名2{}
    2.实现类还可以继承一个类的同时实现多个接口
    public class 类名 extends 父类 implements 接口名1，接口名2{}
// 定义Shape接口
public interface Shape {double calculateArea();  // 计算面积default void display() {  // 默认方法System.out.println("This is a shape");}
}// 圆形实现
public class Circle implements Shape {private double radius;public Circle(double radius) {this.radius = radius;}@Overridepublic double calculateArea() {return Math.PI * radius * radius;}
}
// 矩形实现
public class Rectangle implements Shape {private double width;private double height;public Rectangle(double width, double height) {this.width = width;this.height = height;}@Overridepublic double calculateArea() {return width * height;}
}
public class Main {public static void main(String[] args) {Shape circle = new Circle(5.0);System.out.println("Circle Area: " + circle.calculateArea());circle.display();  // 调用默认方法Shape rectangle = new Rectangle(4.0, 6.0);System.out.println("Rectangle Perimeter: " + rectangle.calculateArea());}
}

2.接口中成员的特点

成员变量
只能是常量
默认修饰符：public static final
构造方法
无
成员方法
只能是抽象方法
默认修饰符：接口中只能定义抽象方法
JDK7以前接口中只能定义抽象方法

3.接口关系

类和类的关系
继承关系，只能单继承，不能多继承，但是可以多层继承
类和接口的关系
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

//乒乓球教练
//属性：姓名，年纪
//行为  教乒乓球，学英语
public abstract class Person {private String name;private int age;public Person() {}public Person(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}
public abstract class Coach extends Person{public Coach() {}public Coach(String name, int age) {super(name, age);}public abstract void teach();
}
public interface LearnEnglish {public abstract void speakEnglish();}
public class TableTennisCoach extends Coach implements LearnEnglish{public TableTennisCoach() {}public TableTennisCoach(String name, int age) {super(name, age);}@Overridepublic void teach() {System.out.println("乒乓球教练教学乒乓球");}@Overridepublic void speakEnglish() {System.out.println("乒乓球教练学英语");}
}

接口和接口的关系
继承关系，可以单继承，也可多继承

public interface Inter1 {public abstract void method1();public abstract void method2();public abstract void method3();
}
public interface Inter2 {public abstract void method1();public abstract void method2();public abstract void method6();
}
public interface Inter3 extends Inter1,Inter2{public abstract void method5();
}

4.JDK8以后接口新增的方法

允许在接口中定义静态方法，需要用static修饰
接口中静态方法的定义格式：
格式：public static 返回值类型方法名(参数列表){ }
范例：public static void show(){ }
注意事项：
静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
public可以省略，static不能省略

允许在接口中定义默认方法，需要使用关键字default修饰，作用是解决接口升级问题
接口中默认方法的定义格式：
格式：public default 返回值类型 方法名(参数列表){ }
范例：public default void show(){ }
注意事项：
默认方法不是抽象方法，所以不强制被重写。
但是如果被重写，重写的时候去掉default关键字 public可以省略，default不能省略
如果实现了多个接口，多个接口中存在相同名字的默认方法，子类就必须对该方法重写

5.接口多态

当一个方法的参数是接口时，可以传递接口所有实现类的对象，这种方式称之为接口多态。

// 定义动物接口
public interface Animal {void makeSound();void move();
}

// 猫类实现动物接口
public class Cat implements Animal {@Overridepublic void makeSound() {System.out.println("猫在喵喵叫");}@Overridepublic void move() {System.out.println("猫在跳跃");}
}

// 狗类实现动物接口
public class Dog implements Animal {@Overridepublic void makeSound() {System.out.println("狗在汪汪叫");}@Overridepublic void move() {System.out.println("狗在奔跑");}
}

// 动物园类，展示接口多态的使用
public class Zoo {// 方法参数为Animal接口类型public static void showAnimalBehavior(Animal animal) {animal.makeSound();animal.move();System.out.println("----------");}public static void main(String[] args) {// 创建不同的动物对象Animal dog = new Dog();Animal cat = new Cat();// 同一个方法，传入不同的实现类对象showAnimalBehavior(dog);  // 传入Dog对象showAnimalBehavior(cat);  // 传入Cat对象}
}

6.适配器设计模式

当一个接口中抽象方法过多，但是我只要使用其中一部分的时候，就可以适配器设计模式
书写步骤：
编写中间类XXXAdapter，实现对应的接口
对接口中的抽象方法进行空实现
让真正的实现类继承中间类，并重写需要用的方法
未来避免其他类创建适配器类的对象，中间的适配类用abstract进行修饰

// 定义一个包含多个抽象方法的接口
public interface Inter {void playAudio();void pauseAudio();void stopAudio();void rewindAudio();void fastForwardAudio();void adjustVolume();void showSubtitles();void changeAspectRatio();void takeScreenshot();
}

// 创建抽象的适配器类，实现接口并对所有方法进行空实现
public abstract class InterAdapter implements Inter{@Overridepublic void playAudio() {}@Overridepublic void pauseAudio() {}@Overridepublic void stopAudio() {}@Overridepublic void rewindAudio() {}@Overridepublic void fastForwardAudio() {}@Overridepublic void adjustVolume() {}@Overridepublic void showSubtitles() {}@Overridepublic void changeAspectRatio() {}@Overridepublic void takeScreenshot() {}
}

// 具体的实现类，只重写需要使用的方法
public class Test extends InterAdapter {@Overridepublic void playAudio() {System.out.println("playAudio");}
}

三、内部类

什么是内部类
写在一个类里面的类就叫做内部类
分类：成员内部类、静态内部类、局部内部类、匿名内部类。
什么时候用到内部类
B类表示的事物是A类的一部分，且B单独存在没有任何意义
如：汽车的发动机、ArrayList的迭代器、人的心脏等等
内部类的访问特点：
内部类可以直接访问外部类的成员，包括私有
外部类要访问内部类的成员，必须创建对象

     public class Car {String carName;int carAge;String carColor;public void show(Car this){Engine e = new Engine();//外部类没engine对象System.out.println(e.engineName);System.out.println(carName);}class Engine{String engineName;int engineAge;public void show(){System.out.println(engineName);System.out.println(carName);}}
}

public class Test {
public static void main(String[] args) {
/*
需求：写一个Javabean类描述汽车
属性：汽车的品牌，车龄，颜色，发动机品牌，使用年限

    内部类的访问特点：内部类可以直接访问外部类的成员，包括私有外部类要访问内部类的成员，必须创建对象*/Car c = new Car();c.carName = "宾利";c.carAge = 1;c.carColor = "粉色";c.show();
}

}

1.成员内部类

  • 写在成员位置的，属于外部类的成员
  • 成员内部类可以被一些修饰符所修饰，比如：private、默认、protected、public、static等
  • 在成员内部类里面，JDK16之前不能定义静态变量，JDK16开始才可以定义静态变量
  • 获取成员内部类对象的两种方式
    方式一：当成员内部类被private修饰时。在外部类编写方法，对外提供内部类对象
    方式二：当成员内部类被非私有修饰时，直接创建对象。
    Outer.Inner oi = new Outer().new Inner();
  • 外部类成员变量和内部类成员变量重名时，在内部类访问外部类成员变量
    sout(Outer.this.变量名);
public class Outer {String name;class Inner{}private class Inner1{}public Inner1 getInstance(){return new Inner1();}
}

public class Test {public static void main(String[] args) {/*获取成员内部类对象的两种方式方式一：外部类编写方法，对外提供内部类对象(private)方式二：直接创建格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象*/Outer.Inner oi = new Outer().new Inner();Outer o = new Outer();o.getInstance();}
}

2.静态内部类

  • 静态内部类只能访问外部类中的静态变量和静态方法，如果想要访问非静态的需要创建对象。
  • 创建静态内部类对象的格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
  • 调用非静态方法的格式：先创建对象，用对象调用
  • 调用静态方法的格式：外部类名.内部类名.方法名();
public class Outer {int a = 10;static int b = 20;//静态内部类static class Inner{public void show1(){Outer o = new Outer();System.out.println(o.a);System.out.println(b);System.out.println("非静态的方法被调用了");}public static void show2(){System.out.println("静态的方法被调用了");}}
}

public class Test {//创建静态内部类的对象//只要是静态的东西，都可以用类名.直接获取public static void main(String[] args) {Outer.Inner oi = new Outer.Inner();oi.show1();//调用静态方法Outer.Inner.show2();}}

3.局部内部类

将内部类定义在方法里面就叫做局部内部类，类似与方法里面的局部变量
外界无法直接使用，需要在方法内部创建对象并使用
该类可以直接访问外部类的成员，也可以访问方法内的局部变量

public class Outer {int b = 20;public void show(){int a = 10;//局部内部类class Inner{String name;int age;public void method1(){System.out.println(a);System.out.println(b);System.out.println("局部内部类中的method1方法");}public static void method2(){System.out.println("局部内部类中的method2方法");}}//创建局部内部类的对象Inner i = new Inner();System.out.println(i.name);System.out.println(i.age);i.method1();Inner.method2();}
}

public class Test {public static void main(String[] args) {Outer o = new Outer();o.show();}
}

4.匿名内部类
隐藏了名字的内部类，可以写在成员位置，也可以写在局部位置。
格式：

new 类名或者接口名(){重写方法;
};

细节：

  • 包含了继承或者实现，方法重写，创建对象。
  • 整体就是一个类的子类对象或者接口的实现类对象

使用场景
当方法的参数就是接口或者类时，以接口为例，可以传递这个接口的实现类对象，如果实现类只要使用一次，就可以用匿名内部类简化代码。

public abstract class Animal {public abstract void eat();
}

public interface Swim {public abstract void swim();
}

public class Test {public static void main(String[] args) {new Swim(){@Overridepublic void swim() {System.out.println("重写了游泳的方法");}};new Animal(){@Overridepublic void eat() {System.out.println("重写了eat方法");}};method(//Animal的子类对象new Animal() {@Overridepublic void eat() {System.out.println("狗吃骨头");}});}public static void method(Animal a){a.eat();}
}
http://www.lryc.cn/news/622254.html

相关文章：

  • 【Golang】：流程控制语句
  • Java 正则表达式的使用方法
  • 开源长期记忆 短期记忆 框架调研对比19999字
  • 如何写好大模型的提示词prompt
  • 第40周——GAN入门
  • 【新手入门】Android基础知识（一）：系统架构
  • 打靶日常-sql注入(手工+sqlmap)
  • 【Java EE进阶 --- SpringBoot】初识Spring（创建SpringBoot项目）
  • 本地生活｜MallBook 分账赋能浙江本地生活服务平台，助力实现资金流转效率与合规性的双提升！
  • 一个集成多源威胁情报的聚合平台，提供实时威胁情报查询和播报服务、主动拦截威胁IP，集成AI等多项常用安全类工具
  • 超级云 APP 模式：重构移动互联网生态的新引擎
  • 高频量化详解，速度和程序化的满足！
  • QT|windwos桌面端应用程序开发，当连接多个显示器的时候，如何获取屏幕编号？
  • Storage.AI解读：构建AI数据基础设施的开放标准
  • 【nginx】如何在本地代理外部链接
  • 《探秘浏览器Web Bluetooth API设备发现流程》
  • Web 安全之 Cookie Bomb 攻击详解
  • 前端动画库之gsap
  • 【Python】一些PEP提案（六）：元类、默认 UTF-8、Web 开发
  • 【LeetCode 热题 100】55. 跳跃游戏
  • 开源数据发现平台：Amundsen Frontend Service 应用程序配置
  • Cursor 分析 bug 记录
  • 基于RobustVideoMatting（RVM）进行视频人像分割（torch、onnx版本）
  • 【机器学习深度学习】客观评估主观评估：落地场景权重比例
  • 四、图与网络模型
  • 大模型性能测试完全指南：从流式响应到多模态的深度实践
  • [激光原理与应用-286]：理论 - 波动光学 - 不同频段电磁波的特点与差异性
  • Docker Compose部署Clickhouse最新版
  • 区块链技术原理(13)-以太坊燃料费Gas
  • 力扣top100(day04-03)--二分查找