Java面向对象——继承+抽象类+接口+内部类（Java笔记作业）

最新推荐文章于 2023-02-21 16:58:58 发布

archerﻬ

最新推荐文章于 2023-02-21 16:58:58 发布

阅读量469

点赞数

分类专栏：笔记老师布置的博文作业文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qq_59109713/article/details/121485146

版权

笔记同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

老师布置的博文作业

4 篇文章 0 订阅

订阅专栏

一、继承

A.继承的定义

继承是一种由已有类创建新类的机制。在Java中，被继承的类称为基类或者父类，由继承形成的类称为派生类或者子类。

B.继承的特点

1.只支持单继承，即一个子类只允许有一个父类。
2. 子类可以拥有父类的属性和方法
3. 子类可以拥有自己的属性和方法
4. 子类可以重写覆盖父类的方法
5. 可以声明父类，创建子类（又称父类装载子类）

C.继承的应用

Java中，一个类只能有一个父类，即类的单继承，使用extends关键字，这个类，称为派生类或子类。代码如下：

[修饰符] class 类名 [extends 父类] {
    //派生类继承基类中非private的成员！！！
    //派生类还可以实现变量的隐藏；
    //派生类还可以实现方法重写。
}

对象的上转型

定义：父类声明的对象，由其子类的构造方法构建。

代码如下：

public class Phone {
    private String number;
    public Phone() {
        super();
        //TODO Auto-generated constructor stub
    }
    public String getnumber() {
        return number;
    }
    public void SetNumber(String number) {
        this.number = number;
    }
    public void callup(String num) {
        System.out.println("calling the"+num);
    }
        phones[1].setNumber("13546758769");
        phones[2].setNumber("13546756369");
        phones[0].setNumber("13546327659");

        for (int i=0;i<phones.lenth;i++){
            phones[i].callup("10086");
            phones[i].acceptCall();
        }
    }
}

特点：

1.对象的上转型，不能再调用子类特有的成员。

2.对象的上转型，只能调用子类重写的方法。

3.对象的上转型，实现了多态性！

二、抽象类

A.抽象的定义

抽象是由abstract修饰的类，就是抽象类。抽象类只用于继承，不能用于创建对象。

B.抽象的特点

抽象类中可以有成员变量、构造方法、实例方法，与普通类一致；

抽象类中还可以有抽象方法。

C.抽象的应用

抽象类的派生类，必须重写所有的抽象方法！

什么是抽象方法

定义：由abstract修饰的方法，就是抽象方法

特点：抽象方法只能声明，不能实现

应用：含有抽象方法的类，必须是抽象类；抽象类的子类，必须重写抽象方法。

代码如下：

public abstract class AbstractClass {
    private int x=100;
    public void show()
    {
        System.out.println("抽象类中可以有成员变量："this.x);
    }
    public abstrac void say();    //抽象方法只能声明不能实现
}
public class SubClass extends AbstractClass {
    public void say(){
        System.out.println("抽象类的子类必须重写抽象方法");
    }
}

D.抽象类的地位

1.用来规划子类都应该有哪些成员；

2.在Java体系中，抽象类一般都是最高的基类。例如IO流

E.抽象类的应用

代码如下;

public abstract class Shapes {
    /**
    *定义抽象类Shapes图形类，包含抽象方法getArea()、getPerimeter();
    **/
    public abstract double getArea();    //获取面积
    public abstract double getPerimeter();    //获取周长
}
public class Circle extends Shapes {
    double r;
    public Circle(double r) {
        this.r = r;
    }
    public double getArea() {
        return r*r*Math.PI;
    }
    public double getPerimeter() {
        return 2*Math.PI *r;
    }
}

三.接口

A.接口的定义

由于Java中并不允许多置继承，但Java提供了接口（interface）来解决这类问题。

接口是用来实现类似多置继承功能的一种结构，它在语法上和类很相似，也有成员变量和方法，接口间也可以形成继承关系，但接口和类有着很大的区别，它的成员变量都是常量，方法都是抽象方法，没有方法体。

代码如下：

[修饰符] <interface> <接口名> [extends 父接口列表]
{
    [public] [static] [finall] 类型 变量名=初始值;    //静态常量
    [public] [abstract] 返回值 方法名 ([参数列表])；    //抽象方法
}

B.接口的特点

1.接口用关键字interface来定义，而不是class。

2.接口中定义的变量全部公有的、静态的、最终的，所以都是常量。

3.接口中定义的方法都是抽象、公有的、所以修饰符可以省略。

4.接口中没有构造方法，而且定义的方法都是抽象方法，所以接口不能创建对象。

5.接口采用多重继承机制，而不是采用类的单重继承机制。

C.接口的应用

一个类要实现某个或某几个接口的使用implements关键字。

一个类可以同时实现多个接口，各接口间用“，”隔开。这个类，称为接口的实现类。

代码如下：

[修饰符] class 类名 [extends 父类] implements 接口1，接口2，接口3 {
    //类体一定要重写接口中的所有方法！！！
}

应用：

使用了接口实现类，必须重写接口中所有的方法！！！

接口回调

定义：接口声明的对象，由其实现类的构造方法构建。

代码如下：

public interface Jumpping {
    public abstract void jump();    //相当于void jump;   
}
public class Cat implements Jumpping {
    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}

public class Dog implements Jumpping {
    @Override
    public void jump() {
        System.out.println("狗狗跑得快，跳的不高");
    }
}


//测试类，或接口类
public calss JumppingDemo {
    public static void main(String[] args) {
  //    Jumpping j = new Jumpping(); //错误，接口不能实例化
        Jumpping j1=new Cat();    //接口回调！！实现的是多态性
        Jumpping j2=new Dog();
        j1.jump();
        j2.jump();
    }
}

D.接口和抽象类的区别

1.接口中的所有方法都是抽象的，而抽象类可以有抽象方法，也可以有实例方法。

2.一个类可以实现多个接口，但只能继承一个父类，接口可以继承多接口。

3.接口与实现它的类不构成继承体系，即接口不是类体系的一部分。因此，不相关的类也可以实现相同的接口，而抽象类是属于类的继承体系，并且一般位于类体系的顶层。

四.内部类

A.内部类的定义

将一个类定义在另一个类的内部，即为内部类，另一个即为外部类。

B.内部类的特点

1.内部类创建对象的方式不一样；

2.内部类生成的字节码不一样。

C.内部类的功能

实现类的多重继承

实例如下：

public class OuterClass {
    int x=100;
    class InnerClass{
        int x=55;
        public void display(){
            System.out.println("内部类的方法,x="+x);
            }
        }
    public void display() {
        System.out.println("内部类的方法,x="+x);
    }
}




class Demo {
    public static void main(String[] args) {
        OuterClass ob1=new OuterClass();
        ob1.display();
        
        OuterClass.InnerClass ob2=new OuterClass().new InnerClass();
        ob2.display();
    }
}

生成的字节码文件，如下：