Java学习day09：super、final关键字，抽象类和接口

不吃~香菜

已于 2023-11-16 10:48:01 修改

阅读量239

点赞数 1

分类专栏： java从0到1 文章标签： java 学习开发语言 java-ee intellij-idea

于 2023-10-10 20:19:07 首次发布

本文链接：https://blog.csdn.net/LF__plus/article/details/133704119

版权

java从0到1 专栏收录该内容

30 篇文章 1 订阅

订阅专栏

声明：该专栏本人重新过一遍java知识点时候的笔记汇总，主要是每天的知识点+题解，算是让自己巩固复习，也希望能给初学的朋友们一点帮助，大佬们不喜勿喷(抱拳了老铁！)

往期回顾

Java学习day08：面向对象三大特性之一：继承_凌~风的博客-CSDN博客

Java学习day07：面向对象三大特性之一：封装_凌~风的博客-CSDN博客

Java学习day06：面向对象基础，构造方法，成员/局部变量_凌~风的博客-CSDN博客

......

Java学习day09：super、final关键字，抽象类和接口

一、super关键字

只能用于继承，并在子类中使用，代表的意思是父类对象

1.1this关键字和super关键字的区别

1.1.1this关键字：

1.代表当前类对象

2.可以调用变量和方法

3.可以调用构造方法

1.1.2super关键字：

1.代表是父类的对象

2.可以调用父类的成员变量和成员方法

3.可以调用父类的构造方法

注意事项:

2.可以调用父类的成员变量和成员方法:

当super调用属性的时候，就是内存里面那一个,也就是说，当我在子类里调用父类成员变量并赋值后，打印子类继承的变量时，会打印出所赋的值。实际上，内存里就只有一个name，子类父类对name的赋值，都是在同一个上修改

class Father{
    String name;

}

class  Son extends  Father{
    public  Son(){
        super.name="666";
    }

    public  void  eat(){
        System.out.println(this.name);
    }
}

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

       Son son=new Son();
       son.eat();

    }

3.可以调用父类的构造方法:

调用无参构造：super()
调用有参构造：super(12)

实际上真实开发的时候，很少使用super，大概率能用到的一个情况就是：super.父类的方法。证明在调用父类的方法

1.1.3示例:

class Father1 {
 String name;
 public Father1 () {
  System.out.println("Father1的无参构造");
 }
 public Father1 (String name) {
  System.out.println("Father1有参构造");
 }
}
class Son1 extends Father1 {
 //在子类中无论你写了有参构造和无参构造，都要去执行父类的无参构造
 //除非你自己调用父类有参构造方法
 public Son1(String name) {
  //在调用父类的无参构造方法
  //super();
  super("狗蛋");
 }
}
public class Demo2 {
 public static void main(String[] args) {
  Son1 son1 = new Son1("狗蛋");
  
 }

}

//在子类中无论你写了有参构造和无参构造，都要去执行父类的无参构造
//除非你自己调用父类有参构造方法

记住这两句话，之前讲过的，需要调用父类的无参构造初始化.

二、抽象类【重要！】

2.1什么是抽象类

在面向对象中，所有的对象可以通过类来创建。反过来说，并不是所有的类都可以创建对象的。如果一个类中没有足够完整的信息来描述具体的对象的话，那么这个类叫抽象类。

在Java中使用关键字abstract修饰类，这个类叫抽象类。

2.2abstract关键字

abstract修饰的类叫抽象类

抽象类必须有抽象方法，可以有非抽象方法，抽象类无法创建实例对象，只能写一个非抽象类去继承抽象类，同时继承后需要重写抽象方法

abstract修饰的方法叫抽象方法，抽象方法没有方法体

总结：abstract 只能修饰类和方法

2.3语法格式

abstarct class 类名｛
普通的方法;
public void eat () {
}
抽象方法;
public abstarct void sleep ();
｝

可以看到，抽象方法是没有方法体的，而有抽象方法的类就是抽象类

示例：

//声明一个抽象类
abstract class Person {
 
 //在抽象类中可以写普通成员方法
 public void eat () {
  System.out.println("今天中午吃外卖。。。。。。");
 }
 //定义一个抽象方法  是不完整的方法  没有方法体的
 abstract public  void work();
 
}
//定义了咋用啊？ 抽象类创建不了对象的 咋解决？
//解决方案: 再写一个普通类去继承抽象类即可
class Man extends Person {
 //the type Man must implement the inherited 
 //abstract method Person.work()
 @Override
 public void work() {
  // TODO Auto-generated method stub
  System.out.println("劳动力");
 }
 
 
}
public class Demo1 {
 public static void main(String[] args) {
  Man man = new Man();
  man.eat();
  man.work();
 }

}

2.3注意事项

1.如果一个类中用abstract修饰的话，那么这个类叫抽象类

2.抽象类中可以有普通成员方法和抽象方法

3.抽象方法没有方法体，是不完整的方法

4.抽象类不能被实例化

5.写一个普通的类去继承抽象类

6.继承后在子类中一定去实现（重写）抽象类中所有的抽象方法

7.非抽象方法可以重写也可以不重写

8.一个抽象类能不能去继承另外一个抽象类？可以的！！！

9.抽象类可以继承非抽象类

大家注意这九条注意事项，基本就把abstract关键字需要注意的地方都包括完了的。

2.3.1示例：

class Cell {
 public void add () {
  System.out.println("分裂");
 }
}
abstract class Animal extends Cell{
 public abstract void run();
}
abstract class Monkey extends Animal{//抽象类
 public void call () {//普通的成员方法
  System.out.println("咿咿呀呀.......");
 }
 public abstract void eat();
 public abstract void sleep();
}
class People extends Monkey {

 @Override
 public void eat() {
  // TODO Auto-generated method stub
  System.out.println("吃肉！！！");
 }

 @Override
 public void sleep() {
  // TODO Auto-generated method stub
  System.out.println("躺着睡。。。");
 }
 @Override
 public void call() {
  System.out.println("嘻嘻哈哈说话");
 }

 @Override
 public void run() {
  // TODO Auto-generated method stub
  System.out.println("人站立奔跑。。。");
 }
 
}
public class Demo2 {
 public static void main(String[] args) {
  People people = new People();
  people.add();
 }
}

2.3.2练习：

抽象类:
Animal:
play()方法抽象方法
eat方法抽象方法
sleep方法普通方法
Panda类去继承Animal
Cat类去继承Animal
实例化Panda Cat 调用上面的几个方法。

abstract  class   Animal{
    public  abstract  void  play();
    public  abstract  void  eat();
    public  void  sleep(){
        System.out.println("睡觉睡觉");
    }
}

class  Panda extends  Animal{
    @Override
    public void play() {
        System.out.println("大熊猫玩耍");
    }

    @Override
    public void eat() {
        System.out.println("吃笋子");
    }
}


class  Cat extends  Animal{
    @Override
    public void play() {
        System.out.println("猫玩耍");
    }

    @Override
    public void eat() {
        System.out.println("吃老鼠");
    }
}

public class Main {
    public static void main(String[] args) {
       Panda panda=new Panda();
       panda.eat();
       panda.play();
       panda.sleep();

       Cat cat=new Cat();
       cat.eat();
       cat.play();
       cat.sleep();

    }

三、final关键字

final修饰符中文意思: 最终的，最后的

3.1用法

1.final可以修饰成员变量	使用final修饰的成员变量，一定要赋值（初始化）。而且不能修改。
2.final可以修饰局部变量	使用final修饰局部变量的时候，可以先对变量不赋值，使用之前进行赋值。但是一旦赋值以后就无法更改。
3.final可以修饰成员方法	final修饰的成员方法不能被重写，牵涉到继承
4.final可以修饰一个类	final修饰的类不能被继承
5.final可以修饰对象的引用	什么是对象的引用？Cat cat=new cat()，这里就是一个对象的引用，修饰对象引用一旦被赋值就无法改变

3.1.1示例

 class Person {
 final String name = "狗蛋";//第1条
 
 public void test () {
   final int i;
  i = 30;
  //i = 80;//第2条：一旦被赋值，就无法改变了
  System.out.println(i);
 }
  public final void eat () {
  System.out.println("吃饭");
 }
}
//class Man extends Person {
// @Override
// public void eat() {   //第3条
//  System.out.println("吃的多");
// }
//}
public class Demo1 {
 public static void main(String[] args) {
  final Person person = new Person();//第5条
  System.out.println("Person:" + person);
  //一旦使用final修饰person 对象引用 是一个固定的内存地址
  Person person1 = new Person();
  System.out.println("Person1:"+ person1);
  //person.name = "嘻嘻";
  //person = person1;//将person1赋值给了person对象
  System.out.println(person);
 }

}

四、接口

4.1生活中的接口

比如USB、插座等，起到一个扩展的功能

4.2Java中的接口

4.2.1语法格式：

interface 接口名字 {
成员变量
成员方法
}

创造接口使用关键字interface，而实现接口使用关键字implements（往下看）

4.2.2注意事项：

1.使用关键字 interface 声明出来一个接口

2.接口下面可以有属性，但是是static 和final修饰的属性。被称为常量。几乎不用

3.接口下面全部是抽象的方法，不带方法体的

4.jdk1.8以后是可以有默认（default）的方法的，这个默认方法带有方法体【重点！！！】

5.接口下面没有构造方法，不能被实例化

6.去使用一个普通的类去实现这个接口，使用关键字implements

7.一定要在实现类中去实现所有的抽象方法

8.一个普通的类可以实现多个接口，弥补了单继承的局限性（注意实现多个接口的写法）

9.一个接口可以去继承另外一个接口（此时实现类要把所有的接口的所有抽象方法全部重写）

4.2.3示例：

interface B2 {
 public void work();
}
interface B1 extends B2{
 public void smoking();
}

interface A1 {
 String NAME = "狗蛋";
 
 
 public void test();
 public void eat();
 public default void sleep () {
  System.out.println("睡觉睡得啥也不知道");
 }
}
class TestA1 implements A1, B1{

 @Override
 public void test() {
  // TODO Auto-generated method stub
  System.out.println("测试");
 }

 @Override
 public void eat() {
  // TODO Auto-generated method stub
  System.out.println("吃东西");
 }
 @Override
 public void sleep() {
  System.out.println("睡得什么都不会了");
 }

 @Override
 public void smoking() {
  // TODO Auto-generated method stub
  System.out.println("不要在整栋楼抽烟！！！");
 }

 @Override
 public void work() {
  // TODO Auto-generated method stub
  
 }
 
}
public class Demo2 {
 public static void main(String[] args) {
  TestA1 testA1 = new TestA1();
  testA1.eat();
  testA1.test();
  testA1.sleep();
 }

}

以上就是今天所有的知识点，下面做题：

五、习题

5.1题目

1、定义一个抽象的"Role"类，有姓名，年龄，性别等成员变量

1)要求尽可能隐藏所有变量(能够私有就私有,能够保护就不要公有)，

再通过GetXXX()和SetXXX()方法对各变量进行读写。具有一个抽象的play()方法，

该方法不返回任何值，同时至少定义两个构造方法。Role类中要体现出this的几种用法。

2)从Role类派生出一个"Employee"类，该类具有Role类的所有成员(构造方法除外)，

并扩展salary成员变量，

同样要有至少两个构造方法，要体现出this和super的几种用法，还要求覆盖play()方法，

并提供一个final sing()方法。

3)"Manager"类继承"Employee"类，有一个final成员变量"vehicle"

在main()方法中制造Manager和Employee对象,并测试这些对象的方法。

2、创建一个Vehicle类并将它声明为抽象类。在Vehicle类中声明一个NoOfWheels方法，
* 使它返回一个字符串值。创建两个类Car和Motorbike从Vehicle类继承，
* 并在这两个类中实现NoOfWheels方法。在Car类中，应当显示“四轮车”信息；
* 而在Motorbike类中，应当显示“双轮车”信息。创建另一个带main方法的类，
* 在该类中创建Car和Motorbike的实例，并在控制台中显示消息。

3.编写步骤：

1. 定义抽象类A，抽象类B继承A，普通类C继承B
2.A类中，定义成员变量numa，赋值为10，抽象showA方法。
3.B类中，定义成员变量numb，赋值为20，抽象showB方法。
4.C类中，定义成员变量numc，赋值为30，重写showA方法，打印numa，重写showB方法，打印numb，定义showC方法，打印numc。
5.测试类中，创建C对象，调用showA方法，showB方法，showC方法。

4.编写步骤：

模拟农学院动物医疗系统信息。
定义抽象家禽类(Poultry)
私有成员变量：动物种类(name)，症状(symptom)，年龄(age)，病因（illness）
提供空参和带参构造方法
成员方法：
抽象方法症状(showSymptom)
普通方法基本信息(showMsg)
提供setXxx和getXxx方法
定义普通鸭子类(Duck)
提供空参和带参构造方法
重写showSymptom方法，打印症状信息

5.编写步骤：

模拟教学管理系统师生信息。
定义Person类。
属性：姓名、年龄
构造方法：无参构造方法，有参构造方法
成员方法：getXxx方法，setXxx方法，显示基本信息showMsg方法
定义Teacher类，继承Person
属性：学科
构造方法：无参构造方法，有参构造方法
成员方法：getXxx方法，setXxx方法，讲课方法
定义Student类，继承Person
属性：分数
构造方法：无参构造方法，有参构造方法
成员方法：getXxx方法，setXxx方法，考试方法

6.电脑类去实现以下的三个接口。
电源接口
鼠标接口
网络接口
比如上面有三个接口，电脑是一个类，让电脑本身不具备插电源连网线连鼠标的
只有在电脑类基础之上去实现三个接口之后，那么电脑就会拥有充电联网连鼠标这些功能的

7假如学校有接待处。接待不同的人，有不同的方式。
| 身份 | 吃 | 住 |
| ---- | -------- | -------- |
| 学生 | 食堂 | 学生宿舍 |
| 老师 | 教师食堂 | 教师公寓 |
| 领导 | 招待所 | 招待所 |
理论上来讲，每个人都是以不同的对象。实现各自的方法
咱们能归纳出来一个模板。让学生老师领导都去实现这个模板。

建议初学者都敲一敲，而且是不看我的答案，先自己敲，很多东西看着会，实际自己上手敲的时候往往会出错。另外题解肯定不止一个，我也只是记录其中一种，大家大可寻找更优解，同时我基本没写注释，希望大家还是多自己思考原因。

5.2部分习题参考答案

abstract  class  Role{
    private String name;
    private int  age;
    private char sex;

    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 char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public  abstract void   play();

    public  Role(){

    }

    public  Role(String name){
        this.name=name;
        System.out.println(name);
    }

    final public  void sing(){
        System.out.println("okk");
    }


}

class  Employee extends  Role{
    String salary;

    public  void  play(){
        System.out.println(super.getName());
    }

    public  Employee(){
        System.out.println("无参构造");
        //System.out.println(super.getAge());
    }

    public  Employee(String name,int age, char sex, String salary){
        this.salary=salary;
        super.setName(name);
        super.setAge(age);
        super.setSex(sex);
        System.out.println(super.getName()+"+"+super.getAge()+"+"+super.getSex()+"+"+this.salary);
    }

}


class  Manager extends Employee{
   final String vehicle="ok";
}


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

        Employee employee=new Employee("bob",12,'1',"000");
        employee.play();

        Manager manager =new Manager();
        manager.sing();

    }

//电源接口
interface Adapter {
 public void input();//充电
}
//USB 接口 连接鼠标
interface USB {
 public void mouse();
}
//网络接口   可以联网
interface Net {
 public void internet();
}
class Computer implements Adapter, USB, Net{

 @Override
 public void internet() {
  // TODO Auto-generated method stub
  System.out.println("联网");
 }

 @Override
 public void mouse() {
  // TODO Auto-generated method stub
  System.out.println("连接鼠标");
 }

 @Override
 public void input() {
  // TODO Auto-generated method stub
  System.out.println("充电！！！");
 }
 
}
public class Demo3 {
 public static void main(String[] args) {
  Computer computer = new Computer();
  computer.mouse();
  computer.input();
  computer.internet();
 }

}

interface Person {
 void eat();
 void sleep();
 
}
class Stdudent implements Person {

 @Override
 public void eat() {
  // TODO Auto-generated method stub
  System.out.println("在学生食堂......");
 }

 @Override
 public void sleep() {
  // TODO Auto-generated method stub
  System.out.println("在宿舍睡觉");
  
 }
 
}
class Teacher implements Person {

 @Override
 public void eat() {
  // TODO Auto-generated method stub
  System.out.println("在教师食堂。。。。。。");
 }

 @Override
 public void sleep() {
  // TODO Auto-generated method stub
  System.out.println("在教师公寓。。。。。。");
 }
 
 
}
class Leader implements Person {

 @Override
 public void eat() {
  // TODO Auto-generated method stub
  System.out.println("招待所吃。。。");
 }

 @Override
 public void sleep() {
  // TODO Auto-generated method stub
  System.out.println("在招待所。。。。");
 }
 
}
public class Demo4 {
 public static void main(String[] args) {
  //实例化三个对象，调用方法即可
 }

}

以上就是今天的所有知识点了，今天的知识点比较多，而且都很重要，特别是抽象类、final关键字、接口等，大家自己要多看多敲多写，才能掌握好这部分内容。

加油吧，预祝大家变得更强！