this super final abstract

最新推荐文章于 2024-09-20 15:32:13 发布

zdryn

最新推荐文章于 2024-09-20 15:32:13 发布

阅读量84

点赞数

文章标签： java

本文链接：https://blog.csdn.net/zdryn/article/details/107705544

版权

this和super

this：是一种引用类型，代表当前对象，保存的是当前的对象的地址
super：代表当前对象的父类，可以调用父亲的成员，但是它不是引用数据类型

abstract class Gpv {
    private double price;
    private String name;
    private int ppu;
//this的使用
    Gpv(double price, String name, int ppu) {
        this.price = price;
        this.name = name;
        this.ppu = ppu;
    }

    public abstract void func();
}
class Ati extends Gpv{
    Ati(double price,String name,int ppu){
        super(price,name,ppu);//父类的使用，但是在用的时候，也要把需要的数据放进去，因为不写的话，他也不知道你要用到谁，就直接不调用了
    }
    public void func(){
        System.out.println("高性能");
    }
}

final

一个关键字，最后的，关键的，被final修饰的内容是不能在被更改的
可修饰的内容：
1、类：但是被final修饰的类，不能有子类：如果有子类，子类会改变的父类的，这就不被允许了
2、成员变量：变量是一个终值，不能再被改变，所以在定义时必须先手动给一个值
3、局部变量
4、方法：final修饰完，不能重写
5、空白final：可以先不给赋值，但是必须在变量使用前给值，就是在构造方法中给值，来保证该属性是被初始化了的

public class Demo8 {
    public static void main(String[] args) {
        //抽象类不能直接创建对象,可以通过子类间接的创建对象.
//        Person person = new Person();
    }
}

//有抽象方法的类必须是抽象类--(前面必须添加哎abstract关键字)
abstract  class  Person{
    //抽象方法--只有方法的声明(前面必须添加哎abstract关键字)
    abstract  void  run();
    void  show(){
        System.out.println("show");
    }
}
//2.如果子类不重写父类的抽象方法,就要将自己变成抽象的
class  Student extends  Person{
    //1.继承自抽象类的子类必须重写父类的抽象方法
    @Override
    void run() {

    }
}

abstract 抽象的

声明：用来不写函数体的函数
作用：1、节省代码量 2、制定一批规则

注意点：
1、抽象类不一定有抽象方法，但是抽象方法一定有抽象类
2、继承了抽象类的子类不一定要实现抽象方法（即子类的重写），不然就将自己变成抽象的
3、抽象类不能直接创建对象必须通过子类实现，所有抽象类一定有子类
4、可以定义属性（变量），但是不可以对存在的变量更改
在这里插入图片描述
5、抽象方法不要不要加身体，写到参数的圆括号就好
例如 public abstract void Methrand();后面加上{}会报错。

比较final abstract static private

1、abstract 不能与final、static、private同时存在
2、final：被final修饰的类不能有子类，方法不能重写，但是abstract必须有子类，必须重写
3、static：修饰的方法可以通过类名调用，abstract必须通过子类实现
4、private：修饰的方法不能重写，abstract必须重写

interface 接口

接口：让Java从单继承间接的实现了多继承，扩充了原来的功能，可以认为是类的补充。
构成;
interface 接口的名字{
成员变量（默认是public、final、static类型）
成员变量（默认是public，abstract类型的）
}
起作用的方式：
让类去实现接口
类与类之间的关系–继承 extends
类与接口之间的关系–实现 implements

注意**
接口与父类可以同时存在
一个子类可以有多个接口
**
父类与接口的功能分配？
一般主类里放的是主要功能，接口放的是额外的功能，接口作为父类的补充。
接口不可以直接创建对象
接口之间可以是继承也可以是多继承
接口中的方法都是抽象的，要通过子类写具体的调用实现，我们看到的方法都是子类的功能

接口的子类重写注意事项：
如果一个类有两个接口，这两个接口同时有相同的抽象方法，只需要在类中重写一次这个方法就行。
如果接口中有default修饰的方法不需要重写。如果两个接口里的方法名相同都是default方法，里面的方法体不同，在类中需要重写该方法。如果两个接口中方法名，参数都相同的方法，一个接口是抽象方法，另一个是default修饰有方法体。这时该类也必须重写该方法

public class Demo10 {
}
//接口是抽象的
interface Inter1{
    int age = 4;//(默认是public,final,static类型的)成员变量;
    public void show();//(默认是public,abstract类型的)成员方法(声明);
}

interface  Inter2{
    public void  run();
    public void  eat();
}

interface  Inter3{
    public void  eat();
}
//同时继承了1,2,3
interface Inter4 extends Inter1,Inter2,Inter3{

}
//多个接口之间使用,隔开
class Cat extends  Object implements Inter4{
//创建一个 继承Object类 的cat类 去来实现inter4接口的各个功能、可以不写object类
    @Override
    public void show() {

    }

    @Override
    public void run() {

    }

    @Override
    public void eat() {

    }
}

刚开始学时对抽象类和接口的功能有点混
个人理解：
抽象类：现在两个子类，有的想要喝汽水，有的想要喝果汁，那么父类再去定义一个喝汽水和喝果汁的功能就不适合他的两个儿子了，现在父类只定义一个功能，给他们钱让他们去买水去，至于买什么水就看他们自己了。总结一句话，我给了你们钱，要干嘛就去干吧。
接口：就像一个菜单栏，我明确告诉你我都有啥功能，就完事了。你来找我干活，ok，我接单，接完单后扭头找了个老师傅，花钱让他帮忙干活，总结一句话相当于中介。
注意：这俩是都是方法，把方法给了其他类。
区别，修饰词不同、功能的实现不同（一个是靠子类实现、一个是靠另一个兄弟类实现）

接口和抽象类注意点

1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。
2、抽象方法的定义：abstract void aaaa() ; 不要加括号
3、接口可以继承接口
4、接口的变量只能是 public、static、final（默认）
5、如果接口和抽象类的继承类不能实现他们的全部功能就只能写成抽象类