Java基础之接口与类

Java之眼

已于 2023-05-11 14:33:15 修改

阅读量451

点赞数 1

文章标签： java

于 2021-03-04 11:09:06 首次发布

本文链接：https://blog.csdn.net/ww702109k/article/details/114363776

版权

Java基础之接口与类

常用的修饰符

Public: (常用)对所有类可见。使用对象：类、接口、变量、方法。

Protected:对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部类）。

Default: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。(可以什么也不写）

Private: (常用)在同一类内可见。使用对象：变量、方法。注意：不能修饰类（外部类）

	同一类	同一包	不同包子类	不同包	使用对象
Public	√	√	√	√	类、接口、变量、方法
Protected	√	√	√		变量、方法。注意：不能修饰类（外部类）
Default	√	√			类、接口、变量、方法
Private	√				变量、方法。注意：不能修饰类（外部类）

类与接口常用关键字

abstract	类或者成员方法具有抽象属性
static	静态属性
final	用来说明最终属性，类不能派生出子类，成员方法不能被覆盖，成员域的值不能被改变
class	类
interface	接口
extends	继承父,类一个类型是另一个类型的子类型，这里常见的类型有类和接口
implements	一个类实现了给定的接口

例如:狗、猫、虎,等属于动物,则动物为一个类;其中一个动物为此类的一个对象、这个对象的属性有:颜色、年龄、名字、行为,等类：类是一个模板，它描述一类对象的行为和状态。
对象：对象是类的一个实例，有状态和行为。

public class Cat {
    //属性
    String breed;
    int size;
    String colour;
    int age;

    //方法
    void eat() {
    }
    void run() {
    }
    void sleep() {
    }
    void name() {
    }

    //无参构造
    public Cat() {
    }
    //有参构造这个构造器仅有一个参数：age
    public Cat(int age) {
    }
}

一个类可以包含以下类型变量：

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。

类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。

抽象类:

public abstract class admin {

    public Result<Account> findById(Integer id){
        return new Result<>(BaseUtils.TWO_HUNDRED);
    }
    //抽象方法
    public abstract double computePay();
}

继承抽象类:

public class Eadmin extends admin {
    public Result<Account> findById(Integer id){
        //业务
        return new Result<>(BaseUtils.TWO_HUNDRED);
    }
    //实现抽象方法
    @Override
    public double computePay() {
        return 0;
    }
    public ResultMsg logout(String token) {
        return new ResultMsg(BaseUtils.FOUR_FIFTEEN, "Exit failed");
    }
}

如果一个类包含抽象方法，那么该类必须是抽象类。

任何子类必须重写父类的抽象方法，或者声明自身为抽象类。

1. 抽象类不能被实例化，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。

2. 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

3. 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。

4. 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。

5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类;不一定实现抽象类中非抽象方法。

接口:多个类的公共规范,只有抽象方法。

特点:

接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。

接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。

接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

public interface IStockService {

    Result<Stock> findByKid(Integer kid);

    Results<Stock> findBySid(Integer sid);

    Result<Stock> findById(Integer id);
}

实现接口:

public class StockService implements IStockService {
    @Resource
    private StockRepository stockRepository;
    @Override
    public Result<Stock> findByKid(Integer kid) {
        Stock stock = stockRepository.findByKid(kid);
        if (stock == null) {
            return new Result<>(BaseUtils.FOUR_FOURTEEN);
        }
        return new Result<>(BaseUtils.TWO_HUNDRED, "OK", stock);
    }
    @Override
    public Results<Stock> findBySid(Integer sid) {
        return new Results<>(stockRepository.findBySid(sid));
    }
    @Override
    public Result<Stock> findById(Integer id) {
        Optional<Stock> optional = stockRepository.findById(id);
        return optional.map(stock -> new Result<>(BaseUtils.TWO_HUNDRED, "OK", stock)).orElseGet(() -> new Result<>(BaseUtils.FOUR_FOURTEEN));
    }
}