面向对象进阶（抽象类&接口&内部类） 第一章 抽象类1.1 概述1.1.1 抽象类引入 1.2 abstract使用格式1.2.1 抽象方法1.2.2 抽象类1.2.3 抽象类的使用
父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了(因为子类对象会调用自己重写的方法)。换句话说，父类可能知道子类应该有哪个功能，但是功能具体怎么实现父类是不清楚的（由子类自己决定），父类只需要提供一个没有方法体的定义即可，具体实现交给子类自己去实现。我们把没有方法体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。
abstract是抽象的意思，用于修饰方法方法和类，修饰的方法是抽象方法，修饰的类是抽象类。
使用abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。
定义格式：
修饰符 abstract 返回值类型 方法名 (参数列表)；代码举例：
public abstract void run()；如果一个类包含抽象方法，那么该类必须是抽象类。注意：抽象类不一定有抽象方法，但是有抽象方法的类必须定义成抽象类。
定义格式：
abstract class 类名字 { }代码举例：
public abstract class Animal { public abstract void run()；}要求：继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。
代码举例：
// 父类,抽象类abstract class Employee {private String id;private String name;private double salary;public Employee() {}public Employee(String id, String name, double salary) {this.id = id;this.name = name;this.salary = salary;}// 抽象方法// 抽象方法必须要放在抽象类中abstract public void work();}// 定义一个子类继承抽象类class Manager extends Employee {public Manager() {}public Manager(String id, String name, double salary) {super(id, name, salary);}// 2.重写父类的抽象方法@Overridepublic void work() {System.out.println("管理其他人");}}// 定义一个子类继承抽象类class Cook extends Employee {public Cook() {}public Cook(String id, String name, double salary) {super(id, name, salary);}@Overridepublic void work() {System.out.println("厨师炒菜多加点盐...");}}// 测试类public class Demo10 {public static void main(String[] args) {// 创建抽象类,抽象类不能创建对象// 假设抽象类让我们创建对象,里面的抽象方法没有方法体,无法执行.所以不让我们创建对象//Employee e = new Employee();//e.work();// 3.创建子类Manager m = new Manager();m.work();Cook c = new Cook("ap002", "库克", 1);c.work();}}此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。
抽象类的特征总结起来可以说是 有得有失
有得：抽象类得到了拥有抽象方法的能力。
有失：抽象类失去了创建对象的能力。
其他成员（构造方法，实例方法，静态方法等）抽象类都是具备的。
不需要背，只要当idea报错之后，知道如何修改即可。
关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。
抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。
抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。
抽象类的子类，必须重写抽象父类中所有的抽象方法，否则子类也必须定义成抽象类，编译无法通过而报错。
理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。
抽象类存在的意义是为了被子类继承。
理解：抽象类中已经实现的是模板中确定的成员，抽象类不确定如何实现的定义成抽象方法，交给具体的子类去实现。
抽象类存在的意义是为了被子类继承，否则抽象类将毫无意义。抽象类可以强制让子类，一定要按照规定的格式进行重写。
我们已经学完了抽象类，抽象类中可以用抽象方法，也可以有普通方法，构造方法，成员变量等。那么什么是接口呢？接口是更加彻底的抽象，JDK7之前，包括JDK7，接口中全部是抽象方法。接口同样是不能创建对象的。
//接口的定义格式：interface 接口名称{ // 抽象方法}// 接口的声明：interface// 接口名称：首字母大写，满足“驼峰模式”在jdk7，包括JDK7之前，接口中的只有包含：抽象方法和常量
注意：接口中的抽象方法默认会自动加上public abstract修饰程序员无需自己手写！！
按照规范：以后接口中的抽象方法建议不要写上public abstract。因为没有必要啊，默认会加上。
在接口中定义的成员变量默认会加上： public static final修饰。也就是说在接口中定义的成员变量实际上是一个常量。这里是使用public static final修饰后，变量值就不可被修改，并且是静态化的变量可以直接用接口名访问，所以也叫常量。常量必须要给初始值。常量命名规范建议字母全部大写，多个单词用下划线连接。
public interface InterF { // 抽象方法！ // public abstract void run(); void run(); // public abstract String getName(); String getName(); // public abstract int add(int a , int b); int add(int a , int b); // 它的最终写法是： // public static final int AGE = 12 ; int AGE = 12; //常量 String SCHOOL_NAME = "程序员";}类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements关键字。
class 类名 implements 接口1,接口2,接口3...{}从上面格式可以看出，接口是可以被多实现的。大家可以想一想为什么呢？
假如我们定义一个运动员的接口（规范），代码如下：
public interface SportMan { void run(); // 抽象方法，跑步。 void law(); // 抽象方法，遵守法律。 String compittion(String project); // 抽象方法，比赛。}接下来定义一个乒乓球运动员类，实现接口，实现接口的实现类代码如下：
package com.itheima._03接口的实现;public class PingPongMan implements SportMan { @Override public void run() { System.out.println("乒乓球运动员稍微跑一下！！"); } @Override public void law() { System.out.println("乒乓球运动员守法！"); } @Override public String compittion(String project) { return "参加"+project+"得金牌！"; }}测试代码：
public class TestMain { public static void main(String[] args) { // 创建实现类对象。 PingPongMan zjk = new PingPongMan(); zjk.run(); zjk.law(); System.out.println(zjk.compittion("全球乒乓球比赛")); }}类与接口之间的关系是多实现的，一个类可以同时实现多个接口。
首先我们先定义两个接口，代码如下：
public interface Law { void rule();}public interface SportMan { void run();}然后定义一个实现类：
public class JumpMan implements Law ,SportMan { @Override public void rule() { System.out.println("尊长守法"); } @Override public void run() { System.out.println("训练跑步！"); }}从上面可以看出类与接口之间是可以多实现的，我们可以理解成实现多个规范，这是合理的。
Java中，接口与接口之间是可以多继承的：也就是一个接口可以同时继承多个接口。大家一定要注意：
类与接口是实现关系
接口与接口是继承关系
接口继承接口就是把其他接口的抽象方法与本接口进行了合并。
案例演示：
public interface Abc { void Go(); void test();}public interface Law { void rule(); void test();} * * 总结： * 接口与类之间是多实现的。 * 接口与接口之间是多继承的。 * */public interface SportMan extends Law , Abc { void run();}不需要背，只要当idea报错之后，知道如何修改即可。
关于接口的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。
只要重写一次即可。此时重写的方法，既表示重写1接口的，也表示重写2接口的。
继承的父类，就好比是亲爸爸一样
实现的接口，就好比是干爹一样
可以继承一个类的同时，再实现多个接口，只不过，要把接口里面所有的抽象方法，全部实现。
实现类可以继承一个抽象类的同时，再实现其他多个接口，只不过要把里面所有的抽象方法全部重写。
处理办法一：如果父类中的方法体，能满足当前业务的需求，在子类中可以不用重写。
处理办法二：如果父类中的方法体，不能满足当前业务的需求，需要在子类中重写。
可以在接口跟实现类中间，新建一个中间类（适配器类）
让这个适配器类去实现接口，对接口里面的所有的方法做空重写。
让子类继承这个适配器类，想要用到哪个方法，就重写哪个方法。
因为中间类没有什么实际的意义，所以一般会把中间类定义为抽象的，不让外界创建对象
将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。可以把内部类理解成寄生，外部类理解成宿主。
一个事物内部还有一个独立的事物，内部的事物脱离外部的事物无法独立使用
按定义的位置来分
成员内部类特点：
内部类的使用格式：
外部类.内部类。 // 访问内部类的类型都是用 外部类.内部类获取成员内部类对象的两种方式：
方式一：外部直接创建成员内部类的对象
外部类.内部类 变量 = new 外部类（）.new 内部类（）;方式二：在外部类中定义一个方法提供内部类的对象
案例演示
方式一：public class Test { public static void main(String[] args) { // 宿主：外部类对象。 // Outer out = new Outer(); // 创建内部类对象。 Outer.Inner oi = new Outer().new Inner(); oi.method(); }}class Outer { // 成员内部类，属于外部类对象的。 // 拓展：成员内部类不能定义静态成员。 public class Inner{ // 这里面的东西与类是完全一样的。 public void method(){ System.out.println("内部类中的方法被调用了"); } }}方式二：public class Outer { String name; private class Inner{ static int a = 10; } public Inner getInstance(){ return new Inner(); }}public class Test { public static void main(String[] args) { Outer o = new Outer(); System.out.println(o.getInstance()); }}编写成员内部类的注意点：
详解：
内部类被private修饰，外界无法直接获取内部类的对象，只能通过3.3节中的方式二获取内部类的对象
被其他权限修饰符修饰的内部类一般用3.3节中的方式一直接获取内部类的对象
内部类被static修饰是成员内部类中的特殊情况，叫做静态内部类下面单独学习。
内部类如果想要访问外部类的成员变量，外部类的变量必须用final修饰，JDK8以前必须手动写final，JDK8之后不需要手动写，JDK默认加上。
请在?地方向上相应代码,以达到输出的内容
注意：内部类访问外部类对象的格式是：外部类名.this
public class Test { public static void main(String[] args) { Outer.inner oi = new Outer().new inner(); oi.method(); }}class Outer {// 外部类 private int a = 30; // 在成员位置定义一个类 class inner { private int a = 20; public void method() { int a = 10; System.out.println(???);// 10 答案：a System.out.println(???);// 20答案：this.a System.out.println(???);// 30答案：Outer.this.a } }}
静态内部类特点：
内部类的使用格式：
外部类.内部类。静态内部类对象的创建格式：
外部类.内部类 变量 = new 外部类.内部类构造器;调用方法的格式：
案例演示：
// 外部类：Outer01class Outer01{ private static String sc_name = "程序"; // 内部类: Inner01 public static class Inner01{ // 这里面的东西与类是完全一样的。 private String name; public Inner01(String name) { this.name = name; } public void showName(){ System.out.println(this.name); // 拓展:静态内部类可以直接访问外部类的静态成员。 System.out.println(sc_name); } }}public class InnerClassDemo01 { public static void main(String[] args) { // 创建静态内部类对象。 // 外部类.内部类 变量 = new 外部类.内部类构造器; Outer01.Inner01 in = new Outer01.Inner01("张三"); in.showName(); }}定义格式:
class 外部类名 {数据类型 变量名;修饰符 返回值类型 方法名(参数列表) {// …class 内部类 {// 成员变量// 成员方法}}}匿名内部类 ：是内部类的简化写法。他是一个隐含了名字的内部类。开发中，最常用到的内部类就是匿名内部类了。
new 类名或者接口名() { 重写方法;};包含了：
继承或者实现关系
方法重写
创建对象
所以从语法上来讲，这个整体其实是匿名内部类对象
实际上，如果我们希望定义一个只要使用一次的类，就可考虑使用匿名内部类。匿名内部类的本质作用
是为了简化代码。
之前我们使用接口时，似乎得做如下几步操作：
interface Swim { public abstract void swimming();}// 1. 定义接口的实现类class Student implements Swim { // 2. 重写抽象方法 @Override public void swimming() { System.out.println("狗刨式..."); }}public class Test { public static void main(String[] args) { // 3. 创建实现类对象 Student s = new Student(); // 4. 调用方法 s.swimming(); }}我们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是做这样的快捷方式。
匿名内部类必须继承一个父类或者实现一个父接口。
匿名内部类格式
new 父类名或者接口名(){ // 方法重写 @Override public void method() { // 执行语句 }};以接口为例，匿名内部类的使用，代码如下：
interface Swim { public abstract void swimming();}public class Demo07 { public static void main(String[] args) { // 使用匿名内部类new Swim() {@Overridepublic void swimming() {System.out.println("自由泳...");}}.swimming(); // 接口 变量 = new 实现类(); // 多态,走子类的重写方法 Swim s2 = new Swim() { @Override public void swimming() { System.out.println("蛙泳..."); } }; s2.swimming(); s2.swimming(); }}通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。代码如下：
interface Swim { public abstract void swimming();}public class Demo07 { public static void main(String[] args) { // 普通方式传入对象 // 创建实现类对象 Student s = new Student(); goSwimming(s); // 匿名内部类使用场景:作为方法参数传递 Swim s3 = new Swim() { @Override public void swimming() { System.out.println("蝶泳..."); } }; // 传入匿名内部类 goSwimming(s3); // 完美方案: 一步到位 goSwimming(new Swim() { public void swimming() { System.out.println("大学生, 蛙泳..."); } }); goSwimming(new Swim() { public void swimming() { System.out.println("小学生, 自由泳..."); } }); } // 定义一个方法,模拟请一些人去游泳 public static void goSwimming(Swim s) { s.swimming(); }}后记
👉👉💕💕美好的一天，到此结束，下次继续努力！欲知后续，请看下回分解，写作不易，感谢大家的支持！！ 🌹🌹🌹
来源地址：https://blog.csdn.net/m0_59230408/article/details/131935122
--结束END--
本文标题: 从零开始学习 Java：简单易懂的入门指南之抽象类&接口&内部类（十一）
本文链接: https://www.lsjlt.com/news/389197.html(转载时请注明来源链接)
有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341
下载Word文档到电脑，方便收藏和打印～
2024-04-03
2024-04-03
2024-04-01
2024-01-21
2024-01-21
2024-01-21
2024-01-21
2023-12-23
回答
回答
回答
回答
回答
回答
回答
回答
回答
回答
官方手机版
微信公众号
商务合作
0