抽象类、接口及内部类

最新推荐文章于 2024-03-30 10:54:08 发布
最新推荐文章于 2024-03-30 10:54:08 发布
阅读量366 收藏 1
点赞数 1
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52459644/article/details/126689948
版权

一、抽象类

1、抽象方法

  • 抽象方法的定义格式：

    public abstract 返回值类型 方法名（参数列表）;

  • 抽象类的定义格式：

    public abstract class 类名{}

2、抽象类和抽象方法的注意事项

  • 抽象类不能实列化

  • 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

  • 可以有构造方法

  • 抽象类的子类

    • 要么重写抽象类中的所有抽象方法

    • 要么是抽象类

3、抽象类的作用是什么样的？

抽取共性时，无法确定方法体，就把方法定义为抽象的。

强制让子类按照某种格式重写。

抽象方法所在的类，必须时抽象类

二、接口

1、接口的定义和使用

  • 接口用关键字interface来定义

    public interface 接口名{}

  • 接口不能实例化

  • 接口和类之间是实现关系，通过implements关键字表示

public class 类名 implements 接口名{}

  • 接口的子类（实现类）

    • 要么重写接口中的所有抽象方法

    • 要么是抽象类

注意1：接口和类的实现关系，可以单实现，也可以多实现。

public class 类名 implements 接口名1，接口名2{}

注意2：实现类还可以在继承一个类的同时实现多个接口。

public class 类名 extends 父类 implements 接口名1，接口名2{}

2、接口中成员的特点

  • 成员变量

    • 只能是常量

    • 默认修饰符：public static final

  • 构造方法

    • 没有

  • 成员方法

    • 只能是抽象方法

    • 默认修饰符：public abstract

  • JDK7以前：接口中只能定于抽象方法

  • JDK8的新特性：接口中可以定义有方法体的方法。

  • JDK9的新特性：接口中可以定义私有方法。

3、接口和类之间的关系

  • 类和类的关系

    • 继承关系，只能单继承，不能多继承，但是可以多层继承

  • 类和接口的关系

    • 实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

  • 接口与接口的关系

    • 继承关系，可以单继承，也可以多继承

练习：编写带有接口和抽象类的标准Javabean类

我们现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练

为了出国交流，跟乒乓球相关的人员都需要学习英语。

请用所有知识分析，在这个案例中，哪些是具体类，哪些是抽象类，哪些是接口?

乒乓球运动员:姓名，年龄，学打乒乓球，说英语

篮球运动员:姓名，年龄，学打篮球

乒乓球教练:姓名，年龄，教打乒乓球，说英语

篮球教练:姓名，年龄，教打篮球

人类 

//人类
public abstract class Person {

    private String name;
    private int age;


    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }


    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Person{name = " + name + ", age = " + age + "}";
    }
}

运动员类 

//运动员类
public abstract class Sporter extends Person{
    public Sporter() {
    }

    public Sporter(String name, int age) {
        super(name, age);
    }

    public abstract void study();
}

教练类

//教练类
public abstract class Coach extends Person{
    public Coach() {
    }

    public Coach(String name, int age) {
        super(name, age);
    }

    public abstract void teach();
}

 说英语的接口

//说英语接口
public interface English {
    public abstract void speakEnglish();
}

乒乓球运动员

//乒乓球运动员
public class PingPangSporter extends Sporter implements English{

    public PingPangSporter() {
    }

    public PingPangSporter(String name, int age) {
        super(name, age);
    }

    @Override
    public void speakEnglish() {
        System.out.println("乒乓球运动员在说英语");
    }

    @Override
    public void study() {
        System.out.println("乒乓球运动员在学习如何打乒乓球");
    }
}

篮球运动员

//篮球运动员
public class BasketballSporter extends Sporter{

    public BasketballSporter() {
    }

    public BasketballSporter(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println("篮球运动员在学习如何打篮球");
    }

}

乒乓球教练

//乒乓球教练
public class PingPangCoach extends Coach implements English{
    public PingPangCoach() {
    }

    public PingPangCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("乒乓球教练正在教如何打乒乓球");
    }

    @Override
    public void speakEnglish() {
        System.out.println("乒乓球在学习说英语");
    }
}

//篮球教练

//篮球教练
public class BasketballCoach extends Coach{

    public BasketballCoach() {
    }

    public BasketballCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("篮球教练正在教如何打篮球");
    }

}

测试类

//测试类
public class Test {
    public static void main(String[] args) {

        //创建运动员或教练的对象
        PingPangSporter pingPangSporter = new PingPangSporter("刘诗雯",23);
        System.out.println(pingPangSporter.getName() +","+pingPangSporter.getAge());
        pingPangSporter.study();
        pingPangSporter.speakEnglish();

    }
}

JDK8开始接口中新增的方法

  • JDK7以前：接口中只能定义抽象方法。

  • JDK8的新特性：接口中可以定义有方法体的方法。（默认 、静态）

  • JDK9的新特性：接口中可以定义私有方法

JDK8以后接口中新增的方法

  • 允许在接口中定义默认方法，需要使用关键字default修饰

    • 作用：解决接口升级的问题

接口中默认方法的定义格式：

  • 格式：public default 返回值类型 方法名（参数列表）{}

  • 范例：public default void show(){}

接口中默认方法的注意事项：

  • 默认方法不是抽象方法，所以不强制被重写。但是如果被重写，重写的时候去掉default关键字

  • public可以省略，default不能省略

  • 如果实现了多个接口，多个接口中存在相同名字的默认方法，子类就必须对该方法进行重写

  • 允许在接口中定义定义静态方法，需要用static修饰

接口中静态方法的定义格式：

  • 格式：public static 返回值类型 方法名（参数列表）{}

  • 范例：public static void show(){}

接口中静态方法的注意事项：

  • 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用

  • public可以省略，static不能省略

 

JDK9新增的方法

接口中私有方法的定义格式：

  • 格式1：private 返回值类型 方法名（参数列表）{}

  • 范例1：private void show(){}

  • 格式2：private static 返回值类型 方法名（参数列表）{}

  • 范例2：private static void method(){}

public interface Inter{
    public default void show1(){
        System.out.println("show1方法开始执行了");
    }
    
    public static void show2(){
        System.out.println("show2方法开始执行了");
    }
    
    //普通的私有方法，给默认方法服务的
    private void show3(){
        System.out.println("记录程序在运行过程中的各种细节，这里有100行代码");
    }
    
    //静态的私有方法，给静态方法服务的
    private static void show3(){
        System.out.println("记录程序在运行过程中的各种细节，这里有100行代码");
    }
    
}

接口的应用

  1. 接口代表规则，是行为的抽象。想要让那个类拥有一个行为，就让这个类实现对应的接口就可以了。

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

适配器设计模式

  • 设计模式（Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。

简单理解：设计模式就是各种套路

  • 适配器设计模式：解决接口与接口实现类之间的矛盾问题

  1. 当一个接口中抽象方法过多，但是我只要使用其中一部分的时候，就可以适配器设计模式

  2. 书写步骤：

    • 编写中间类XXXAdapter，实现对应的接口

    • 对接口中的抽象方法进行空实现

    • 让真正的实现类继承中间类，并重写需要用的方法

    • 为了避免其他类创建适配器类的对象，中间的适配器类用abstract进行修饰

三、内部类

类的五大成员：属性、方法、构造方法、代码块、内部类

1、什么是内部类

在一个类的里面，再定义一个类。

举例：在A类的内部定义B类，B类就被称为内部类

public class Outer{	//外部类
    public class Inner{	//内部类
        
    }
}

2、为什么要学习内部类

需求：写一个Javabean类描述汽车。

属性：汽车的品牌，车龄，颜色，发动机的品牌，使用年限。

public class Car{	//外部类
    String carName;
    int carAge;
    int carColor;
    
    //内部类表示的事物是外部类的一部分
    //内部类单独出现没有任何意义
    class Engine{	//内部类
        String engineName;
        int engineAge;
    }
}

内部类的访问特点

  • 内部类可以直接访问外部类的成员，包括私有

  • 外部类要访问内部类的成员，必须创建对象

1、成员内部类(没多大用)

  • 写在成员位置的，属于外部类的成员。

  • 成员内部类可以被一些修饰符所修饰，比如：private，默认，protected，public，static等。

  • 在成员内部类里面，JDK16之前不能定义静态变量，JDK16开始才可以定义静态变量。

public class Car{	//外部类
    String carName;
    int carAge;
    int carColor;

    private class Engine{	//成员内部类
        String engineName;
        int engineAge;
    }
}

获取内部类对象

方式一：

在外部类中编写方法，对外提供内部类的对象（private）

方式二：直接创建

格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象；

范例：Outter.Inner oi = new Outer().new Inner();

public class Outer{
    String name;
    
    class Inner{
        
    }
}
//当内部类没有被私有化时
public class Test{
    public static void main(String[] args){
        Outer.Inner oi = new Outer().new Inner();
    }
}
public class Outer{
    String name;
    
    private class Inner{
        
    }
    
    public Inner getInstance(){
        return new Inner();
    }
}
//当内部类被私有化时,可以这样做
public class Test{
    public static void main(String[] args){
        Outer o = new.Outer();	
        //这样可以
        Object Inner = o.getInstance();
        System.out.println(Inner);
        //这样也可以
        System.out.println(o.getInstance());
    }
}

外部类成员和内部类成员变量重名时，在内部类如何访问

public class Outer{
    private int a = 10;
    
    class Inner{
        private int a = 20;
        
        public void show(){
            int a = 30;
            System.out.println(a);	//30
            System.out.println(this.a);	//20
            System.out.println(Outer.this.a);	//10
        }
    }
}

2、静态内部类(没多大用)

静态内部类只能访问外部类中的静态变量和静态方法，如果想要访问非静态的需要创建对象

public class Car{	//外部类
    String carName;
    
    int carAge;
    int carColor;

    static private class Engine{	//静态内部类
        String engineName;
        int engineAge;
    }
}

创建静态内部类对象的格式：外部类名.内部类名 对象名 = new 外部类名.内部类名()；

调用非静态方法的格式：先创建对象，用对象调用

调用静态方法的格式：外部类名.内部类名.方法名();

3、局部内部类(没多大用)

  1. 将内部类定义在方法里面就叫做布局内部类，类似于方法里面的局部变量。

  2. 外界是无法直接使用，需要在方法内部创建对象并使用

  3. 该类可以直接访问外部类的成员，也可以访问方法内的局部变量。

public class Outer{
    public void show(){
        int a = 10;
        
        //局部内部类
        class Inner{
            String name;
            int age;
            
            public void method1(){
                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.method2();
        Inner.method2();
        
        
    }
}

4、匿名内部类(重要)

匿名内部类本质上就是隐藏了名字的内部类。

1、什么是匿名内部类？

隐藏了名字的内部类，可以写在成员位置，也可以写在局部位置。

2、匿名内部类

格式：

new 类名或者接口名（）{
        重写方法；
    };

（格式细节）

包含了继承或实现，方法重写，创建对象。

整体就是一个类的子类对象或者接口的实现类对象

举例：

new Inter(){
		public void show(){
            
        }
	};
//接口
public interface Swin{
    public abstract void swim();
}

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

public class Test{
    public static void main(String[] args){
        //编写匿名内部类的代码
        new Swim(){
            @Override
            public void swim(){
                System.out.println("重写了游泳方法");
            }
        };
        new Animal(){
            @Override
            public void eat(){
                System.out.println("重写了吃饭方法");
            }
        };
        
        
        method(
        	new Animal(){
            	@Override
            	public void eat(){
                	System.out.println("狗吃骨头");
          	 	}
    	    }
        );
        
    }
    
    public static void method(Animal a){
        a.eat();
    }
    
}

3、使用场景

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

题外扩展

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

public class Test {

    public static void main(String[] args) {
        /*
        *   回顾一下匿名内部类的格式
        *       new 类/接口(){
        *           重写的方法;
        *       }
        *
        * */

        //整体我们可以理解为Swim接口的实现类对象
        //接口多态
        Swim s = new Swim(){
            @Override
            public void swim() {
                System.out.println("重写之后游泳的方法");
            }
        };

        //编译看左边，运行看右边
        s.swim();


        new Swim(){
            @Override
            public void swim() {
                System.out.println("重写之后游泳的方法");
            }
        }.swim();

    }

}

BoyFriend1005
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
接口和抽象类练习：教练和运动员案例： （1）人员：乒乓球运动员和篮球运动员。乒乓球教练和篮球教练。 （2）为了出国交流，跟乒乓球相关的人员都需要学习英语。 请用所学知识分析，设计类和接口。
qq_41005604的博客
06-28 5636
接口和抽象类的练习 需求分析： 教练和运动员案例： （1）人员：乒乓球运动员和篮球运动员。乒乓球教练和篮球教练。 （2）为了出国交流，跟乒乓球相关的人员都需要学习英语。 请用所学知识分析，设计类和接口。 1、声明Person抽象类，没有抽象方法， 但有属性，姓名等，有方法，吃饭void eat()、睡觉void sleep()等 2、声明教练Coach抽象类，他继承Person类，并增加一个void teach()抽象方法 它有两个子类：兵兵球教练和篮球教练，分别实现void teach()方法 兵兵球教练
抽象类和接口
clover_oreo的博客
06-28 245
当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类！抽象类和抽象方法必须使用 abstract 关键字修饰 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类抽象类不能实例化抽象类如何实例化呢？参照多态的方式，通过子类对象实例化，这叫抽象类多态抽象类的子类要么重写抽象类中的所有抽象方法要么是抽象类成员的特点成员变量既可以是变量也可以是常量构造方法空参构造有参构造
Java_笔记_抽象类_接口
SisinRyu的博客
12-09 1189
Java_笔记_抽象类_接口
day10 内部类
m0_51672857的博客
05-06 39
成员内部类可以被一些修饰符所修饰，比如：public，默认，protected，public，static等。2)创建静态内部类对象的格式：外部类名.内部类名 对象名=new 外部类名.内部类名();1)静态内部类只能访问外部类中的静态变量和静态方法，如果想要访问非静态的需要创建对象。方式二：直接创建格式：外部类名.内部类名 对象名=外部类对象.内部类对象。1)将内部类定义在方法里面就叫局部内部类，类似于方法里面的局部变量。3)该类可以直接访问外部类的成员，也可以访问方法内的局部变量。
37Java内部类
qq_61176213的博客
10-25 503
将一个类A定义在另一个类B里面，则这个类A就被称为内部类，类B被称为外部类，内部类表示的事物是外部类的一部分。内部类单独出现没有任何意义。
java抽象类和接口定义与用法详解
08-25
Java 抽象类和接口定义与用法详解 Java 抽象类是一种特殊的类，它提供了一个模板，所有的子类都是在此模板的基础之上添加和修改完善功能而创建出来的。抽象类定义了抽象方法，即没有具体实现的方法，子类必须实现...
Java的接口、内部类、常用类
12-22
接口相当于特殊的抽象类，定义方式、组成部分于抽象类类似。 微观概念:接口是一种能力和约定 接口的定义:代表了某种能力 方法的定义:能力的具体要求 经验:Java为单继承，当父类方法种类无法满足子类需求时，可实现...
Kotlin 创建接口或者抽象类的匿名对象实例
08-19
在Kotlin编程中，接口和抽象类是用来定义行为规范的重要工具。它们允许我们定义一系列方法，而无需提供具体的实现。接口通常用于强制实现特定的方法，而抽象类则可以包含一些默认实现。在某些情况下，我们需要在运行...
接口与抽象类区别
09-15
5. 抽象类是从一系列相关对象中抽象出来的概念， 因此反映的是事物的内部共性；接口是为了满足外部调用而定义的一个功能约定， 因此反映的是事物的外部特性。 6. 接口基本上不具备继承的任何具体特点,它仅仅承诺了...
2022年接口内部类和JavaAPI基础.ppt
11-03
"2022年接口内部类和JavaAPI基础" 一、接口 1.1 声明接口 在Java中，接口是用来定义一组方法的集合，用于描述一个类的行为。声明接口使用关键字`interface`，例如： ```java public interface Area { public ...
Java面向对象思想_抽象类_编写带有抽象类的JavaBean类——小练习
最新发布
wsxcjg的博客
03-30 496
java面向对象思想_抽象类_编写带有抽象类的JavaBean类——小练习 青蛙Frog 属性：名字，年龄 行为：吃虫子，喝水 狗Dog 属性：名字，年龄 行为：吃虫子，喝水 羊Sheep 属性：名字，年龄 行为：吃虫子，喝水
案例：运动员和教练（接口和抽象类）
遇到困难，想出办法，解决困难，代码的本质就是对解决问题思路的模拟！代码其根本的标准就是能解决问题的代码就是好代码
10-13 196
20英里法则
抽象类和抽象方法（Java）
时刻总结
12-29 451
抽象类和抽象方法的笔记 介绍 定义格式 注意事项 课后练习
抽象类的内部类
另一个世界
05-04 1904
抽象类的内部类 内部抽象类
Java抽象类（内部抽象类）
Java软贱攻城狮
03-11 1497
abstract class A { public abstract void print(); private static class B extends A { public void print() { System.out.println("Hello"); } } public static A getInstance() { return new B()...
java 抽象内部类创建_Java基础--抽象、接口、内部类
weixin_28840811的博客
02-25 228
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------ Java面向对象要点问题总结2 1、继承： (1)提高代码的复用性； (2)使类与类之间产生关系第一讲 抽象类一、抽象类的概述1、抽象类：当多个类中出现相同功能，但是功能主体不同...
抽象类+内部类使用
Leovany的专栏
04-09 1600
一、目的 通过学生编号（Student_id ），找到对应 的班级 二、说明 需掌握知识： 抽象类 类部类 三、实例代码 1、ClassRoom.java package abstract_test; public abstract class ClassRoom { // 根据学生id 找到 对应 班级 private String classRoom; publi
"Java接口与内部类：抽象类、抽象方法和接口的关系与特点
不能实例化抽象类的对象，而从抽象类继承的子类必须重写所有的抽象方法，否则它自己也将成为抽象类。 通过这些概念的理解和应用，我们可以更好地实现面向对象编程的原则，使得代码更加灵活和可扩展。通过Java接口和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值