JAVA.抽象、接口、内部类

最新推荐文章于 2024-08-01 15:05:06 发布
最新推荐文章于 2024-08-01 15:05:06 发布
阅读量407 收藏 4
点赞数 3
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78955442/article/details/140671468
版权

1.抽象

共性，父类定义抽象方法，子类必须重写，或者子类也是抽象类

示例代码

animal

package animalabstract;

//定义抽象类animal
public abstract class animal {

    String name;
    int age;

    //定义抽象方法eat，子类必须重写
    public abstract void eat();
}

rabbit

package animalabstract;

public class rabbit extends animal{

    @Override
    public void eat() {
        System.out.println("rabbit eat 胡萝卜");
    }
}

frog

package animalabstract;

public class frog extends animal{
    @Override
    public void eat() {
        System.out.println("frog eat 虫子");
    }
}

dog

package animalabstract;

public class dog extends animal{


    @Override
    public void eat() {
        System.out.println("dog eat 骨头");
    }
}

Test

package animalabstract;

public class Test {
    public static void main(String[] args) {
        rabbit rb = new rabbit();
        rb.eat();
        frog fg = new frog();
        fg.eat();
        dog dog = new dog();
        dog.eat();
    }
}

抽象类里面可以有构造方法，比如

2.接口

示例代码

swim

package animalabstract;

public interface swim {
    public void swim();
}

用上面抽象的示例代码，animal和rabbit不用改，但是dog类和frog类需要实现swim接口，需要改

dog

package animalabstract;

public class dog extends animal implements swim{


    @Override
    public void eat() {
        System.out.println("dog eat 骨头");
    }

    @Override
    public void swim() {
        System.out.println("dog 狗刨");
    }
}

frog

package animalabstract;

public class frog extends animal implements swim{
    @Override
    public void eat() {
        System.out.println("frog eat 虫子");
    }

    @Override
    public void swim() {
        System.out.println("frog 蛙泳");
    }
}

Test

package animalabstract;

public class Test {
    public static void main(String[] args) {
        rabbit rb = new rabbit();
        rb.eat();
        frog fg = new frog();
        fg.eat();
        fg.swim();
        dog dog = new dog();
        dog.eat();
        dog.swim();
    }
}

成员变量

只能是常量，默认 public static final

构造方法

没有

成员方法

抽象方法等， public abstract

3.接口，类之间的关系

实现多个接口里面有重名的方法也没事，因为是抽象的，需要重写

示例代码

代码结构

package coachplayer;

public abstract class person {
    String name;
    int age;

    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 String info();
}

package coachplayer;

public abstract class player extends person{
    public player(String name, int age) {
        super(name, age);
    }
    public abstract String info();
    public abstract void study();
}

package coachplayer;

public abstract class coach extends person{

    public coach(String name, int age) {
        super(name, age);
    }
    public abstract String info();
    public abstract void teach();
}

package coachplayer;

public class ppplayer extends player implements english {

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

    @Override
    public String info() {
        return this.name + " " + this.age ;
    }

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

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

package coachplayer;

public class bbplayer extends player{
    public bbplayer(String name, int age) {
        super(name, age);
    }
    @Override
    public String info() {
        return this.name + " " + this.age ;
    }
    @Override
    public void study() {
        System.out.println("篮球运动员打篮球");
    }
}

package coachplayer;

public class ppcoach extends coach implements english{
    public ppcoach(String name, int age) {
        super(name, age);
    }
    @Override
    public String info() {
        return this.name + " " + this.age ;
    }
    @Override
    public void teach() {
        System.out.println("乒乓球教练教乒乓球");
    }

    @Override
    public void english() {
        System.out.println("乒乓球教练说英语");
    }
}

package coachplayer;

public class bbcoach extends coach {


    public bbcoach(String name, int age) {
        super(name, age);
    }
    @Override
    public String info() {
        return this.name + " " + this.age ;
    }
    @Override
    public void teach() {
        System.out.println("篮球教练教篮球");
    }
}

package coachplayer;

public interface english {
    public void english();
}

package coachplayer;

public class Test {
    public static void main(String[] args) {

        ppplayer ppl=new ppplayer("leo",18);
        ppl.study();
        ppl.english();
        System.out.println(ppl.info());
        bbplayer bbl=new bbplayer("jack",20);
        bbl.study();
        System.out.println(bbl.info());
        ppcoach ppc=new ppcoach("james",50);
        ppc.teach();
        ppc.english();
        System.out.println(ppc.info());
        bbcoach bbc=new bbcoach("amy",40);
        bbc.teach();
        System.out.println(bbc.info());

    }
}

4.接口特殊方法

default

在接口里定义  fun，默认  public abstract ，所以在实现这个接口的时候，就必须对该方法重写

package interface3tips;

public interface inter0 {

    public abstract void fun();
}



package interface3tips;

public class class1 implements inter0{
    @Override
    public void fun() {
        System.out.println("class继承了inter0");
    }
}

package interface3tips;

public class TEST {
    public static void main(String[] args) {
        class1 c1 = new class1();
        c1.fun();
    }
}

但是，把abstract改成default，实现这个接口的时候就不需要重写，因为他是默认的方法，你可以重写也可以不重写，然后可以直接使用

package interface3tips;

public interface inter0 {

    public default void fun(){
        System.out.println("fun的default");
    }
}



package interface3tips;

public class class1 implements inter0{

}

package interface3tips;

public class TEST {
    public static void main(String[] args) {
        class1 c1 = new class1();
        c1.fun();
    }
}

static

package interface3tips;

public interface inter0 {

    public default void fun(){
        System.out.println("fun的default");
    }
    public static void show(){
        System.out.println("inter0的静态方法");
    }
}



package interface3tips;

public class class1 implements inter0{

}

package interface3tips;

public class TEST {
    public static void main(String[] args) {
        class1 c1 = new class1();
        c1.fun();
        inter0.show();
    }
}

private

package interface3tips;

public interface inter0 {

    public default void fun(){
        System.out.println("fun的default");
        fun1();
    }
    public static void show(){
        System.out.println("inter0的静态方法");
    }
    private void fun1(){
        System.out.println("私有方法，外类访问不到");
    }
}

‘

package interface3tips;

public class class1 implements inter0{

}

package interface3tips;

public class TEST {
    public static void main(String[] args) {
        class1 c1 = new class1();
        c1.fun();
        inter0.show();
    }
}


package interface3tips;

public interface inter0 {

    public default void fun(){
        System.out.println("fun的default");
        fun1();
    }
    public static void show(){
        System.out.println("inter0的静态方法");
        fun2();
    }
    private void fun1(){
        System.out.println("私有方法，外类访问不到");
    }
    private static void fun2(){
        System.out.println("私有静态方法，外类访问不到");
    }
}



package interface3tips;

public class class1 implements inter0{

}

package interface3tips;

public class TEST {
    public static void main(String[] args) {
        class1 c1 = new class1();
        c1.fun();
        inter0.show();
    }
}

5.适配器

  当接口inter0有很多个抽象方法，那么一个类class1继承的时候就必须重写所有的抽象方法，但我不想这样，所以先创建一个新的类作为适配器inter0Adapter，实现这个接口，然后再用类来继承这个适配器类  class1 extends interAdapter，这样我的class1类就不用重写inter0的所有抽象方法

package interface3tips;

public interface inter0 {

    public abstract void fun1();
    public abstract void fun2();
    public abstract void fun3();
    public abstract void fun4();
    public abstract void fun5();


}



package interface3tips;

public abstract class inter0Adapter implements inter0{
    @Override
    public void fun1() {
        System.out.println("适配器的fun1");
    }

    @Override
    public void fun2() {
        System.out.println("适配器的fun2");
    }

    @Override
    public void fun3() {
        System.out.println("适配器的fun3");
    }

    @Override
    public void fun4() {
        System.out.println("适配器的fun4");
    }

    @Override
    public void fun5() {
        System.out.println("适配器的fun5");
    }
}

package interface3tips;

public class class1 extends inter0Adapter{

    @Override
    public void fun5(){
        System.out.println("只用到fun5");
    }

}

package interface3tips;

public class TEST {
    public static void main(String[] args) {
    class1 c1 = new class1();
    c1.fun1();
    c1.fun5();
    }
}

6.内部类

1.成员内部类

package Inclass;


public class Outer{

    String name;
    Iner I1;

    public Outer(String name) {
        this.name = name;

    }

    public Outer() {
    }

    class Iner{
        int age;

        public Iner() {
        }

        public Iner(int age) {
            this.age = age;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        @Override
        public String toString() {
            return "Iner{" +
                    "age=" + age +
                    '}';
        }
    }


    public Iner getI1() {
        if (I1 == null) {
            I1 = new Iner(0); // 默认年龄为 0
        }
        return I1;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Outer{" +
                "name='" + name + '\'' +
                ", I1=" + I1.toString() +
                '}';
    }

    public void setI1(Iner i1) {
        I1 = i1;
    }

}

package Inclass;

public class Test {

    public static void main(String[] args) {
        // 方法1，直接创建
      Outer Outer1=new Outer("jack");
      Outer.Iner Iner1=Outer1.new Iner(18);
      Outer1.setI1(Iner1);
      System.out.println(Outer1);

      // 方法2，外部类编写方法返回内部类n对象
        Outer Outer2=new Outer("james");
        Outer.Iner Iner2=Outer2.getI1();
        Iner2.setAge(20);
        System.out.println(Outer2);

    }
}

2.静态内部类

3.局部内部类

4.匿名内部类

匿名内部类是一个对象来的，只是没有名字，只用一次，就不用在创建一个类了

package Inclass;


public abstract class Outer{

    String name;

    public Outer(String name) {
        this.name = name;

    }

    public Outer() {
    }





    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Outer{" +
                "name='" + name + '\'' +
                '}';
    }

    public abstract void show();


}
package Inclass;

public class Test {

    public static void main(String[] args) {

        new Outer() {

        public  void show () {
            System.out.println("我是匿名内部类");
        }
    }.show();


    }
}

也可以创建一个对象接收，然后再用

package Inclass;

public class Test {

    public static void main(String[] args) {

         Outer o1= new Outer() {

        public  void show () {
            System.out.println("我是匿名内部类");
        }
    };
         o1.show();


    }
}

终将超越过去
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java抽象类和接口定义与用法详解
08-25
Java 抽象类和接口定义与用法详解 Java 抽象类是一种特殊的类，它提供了一个模板，所有的子类都是在此模板的基础之上添加和修改完善功能而创建出来的。抽象类定义了抽象方法，即没有具体实现的方法，子类必须实现...
2022年接口内部类和JavaAPI基础.ppt
11-03
"2022年接口内部类和JavaAPI基础" 一、接口 1.1 声明接口 在Java中，接口是用来定义一组方法的集合，用于描述一个类的行为。声明接口使用关键字`interface`，例如： ```java public interface Area { public ...
Java【抽象类和接口】是什么？
yzhcjl_的博客
11-18 1406
记录学习过程——Java【抽象类和接口】
【Java】抽象类&接口
qq_74455045的博客
05-02 1967
抽象类；实现多个接口；接口之间的关系；Comparable接口；Comparator接口；Clone接口；抽象类与接口的区别
java 抽象 接口 内部类
xuyuanmeng的博客
06-12 1511
定义public interface 接口名{抽象方法;接口不能实例化接口和类之间是实现关系可以单实现，也可以多实现可以在继承一个类的同时实现多个接口public class Lei implements 接口名{}public class Lei implements 接口名1，接口名2{}public class Lei extends Fu implements 接口名1，接口名2{}接口的子类（实现类）重写接口中的所以抽象方法本身是抽象类。
Java的抽象类和接口
weixin_73616913的博客
03-28 1766
对于面向对象编程来说，抽象是它的一大特征之一。在 Java 中，可以通过两种形式来体现 OOP 的抽象：接口和抽象类。这两者有太多相似的地方，又有太多不同的地方。很多人在初学的时候会以为它们可以随意互换使用，但是实际则不然。今天我们就一起来学习一下Java中的接口和抽象类。抽象方法必须用 abstract 关键字进行修饰。如果一个类含有抽象方法，则称这个类为抽象类，抽象类必须在类前用 abstract 关键字修饰。因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。
JAVA抽象类和接口
weixin_64903131的博客
07-15 4674
Java中抽象类和接口的介绍
【Java】抽象类和接口
trong_ 的烂笔头
08-18 3421
抽象类、接口的介绍和区别
Java: Java中接口和抽象类的区别以及应用场景
GIS摆渡人
08-03 1869
比如，男人，女人，这两个类，他们的抽象类是人。人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它。在JAVA编程语言中是接口一个抽象类型，是抽象方法的集合，接口通常以interface来声明。：某个问题需要子类除了需要重写父类的abstract的方法，还需要从父类继承变量或者重写重要的非abstract方法，就考虑abstract类。所以，在高级语言上，一个类只能继承一个类（抽象类）(正如人不可能同时是生物和非生物)，但是可以实现多个接口(吃饭接口、走路接口)。...
抽象类、接口
yu的博客
05-28 2534
关键字、接口、抽象类
Java内部类、抽象类、泛型和接口
cnds123的专栏
12-29 1184
Java内部类、泛型类和接口 本讲介绍Java面向对象的高级部分。对这一部分内容仅作必要而非深入的介绍。 一、Java内部类 在Java 语言中的类可以嵌套定义，允许在另外一个类中定义一个类，即在一个类的类体中可以嵌套（nested）定义另外一个类。外层的称为外部类（outer class），也可以叫做封闭类;内部的称为内部类（Inner Classes），有时也称为嵌套类(Nested Class)。内部类可以是静态(static)的，可以使用 public、protected 和 priva.
Java之抽象类和接口
2301_79404878的博客
04-27 3645
（只能是public abstract，其他修饰符都会报错3.接口中的方法是不能在接口中实现的，只能由实现接口的类来实现。
Java的接口、内部类、常用类
12-22
JAVA接口、内部类、常用类 一、JAVA接口 1.1 什么是接口？: 接口相当于特殊的抽象类，定义方式、组成部分于抽象类类似。 微观概念:接口是一种能力和约定 接口的定义:代表了某种能力 方法的定义:能力的具体要求 经验:...
Java 抽象类
05-23
通过学习和熟练掌握Java抽象类，开发者能够更好地设计和组织代码，提高代码的灵活性和可维护性，是成为一名优秀Java程序员的必备技能之一。在实际开发中，合理利用抽象类和接口，可以帮助我们构建出高效、可扩展的...
Java嵌套类和内部类详解
09-03
- 匿名内部类：没有名称的内部类，通常用于快速实现简单的接口或抽象类的子类。 内部类的实例总是与外部类的实例关联，也就是说，要创建内部类的实例，必须先有一个外部类的实例。这使得内部类可以用来封装与外部...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 602
1.导入hutool的maven依赖。2.复制一下代码执行。
深入理解Java注解
最新发布
weixin_55745942的博客
08-01 559
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
社区养老服务小程序的设计
Karen198的博客
07-31 515
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
JavaSE面向对象进阶
qq_45348840的博客
07-30 478
需求：在实际开发中，经常会遇到一些数组使用的工具类;请按照如下要求编写一个数组的工具类：ArrayUtil提供一个工具类方法printArr,用于返回整数数组的内容。返回的字符串格式如：[10,20,50,34,100 ]（只考虑整数数组，且只考虑一维数组)提供这样一个工具方法getAerage,用于返回平均分。（只考虑浮点型数组，且只考虑一维数组)定义一个测试类TestDemo,调用该工具类的工具方法，并返回结果。// 私有化构造方法// 定义静态方法，方便调用。i++) {
"Java接口与内部类：抽象类、抽象方法和接口的关系与特点
Java 接口和内部类是面向对象编程中的重要概念，它们可以帮助实现代码的灵活性和可扩展性。接口是一种抽象的类型，它定义了一组方法的约定，而不包含具体的实现。内部类则是定义在其他类内部的类，可以实现更加紧密...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值