学习JAVA知识总结--类Class,抽象类,接口interface

何为枕边人

已于 2022-04-28 17:01:07 修改

阅读量908

点赞数 2

文章标签： java

于 2022-04-25 18:09:44 首次发布

本文链接：https://blog.csdn.net/qq_51898604/article/details/124408059

版权

一、Class的定义

关键字：class

作用：将具体的事物抽象成模型

修饰符：public private final

类的组成：一般由“属性”，“构造方法”，“方法”

实例类：new 类名(<初始化属性>)（类名规范：首字母大写）

*注意一个java文件只能有一个public修饰的类

编写Animal.java

package zhm;

public class Animal {
    //类的属性
    String name;
    //类的方法
    //与类同名称为构造器，一般用于初始化属性
    //    有参数
    Animal(String name){
        this.name = name;
    }
    //    无参数
    Animal(){
        this.name = "一只猫";
    }
    //一般set开头称为设置器
    public void setName(String name) {
        this.name = name;
    }
    //一般get开头称为访问器
    public String getName() {
        return name;
    }
    //一般方法
    public void run(){
        System.out.println("--正在行动中--");
    }
}

编写Main.java

package zhm;

public class Main {
    public static void main(String[] args){
        Animal cat = new Animal();
        Animal cat2 = new Animal("狸花猫");
        Animal cat3= new Animal();
        //cat.name = "三花猫"
        cat.setName("布偶猫");
        cat.run();//布偶猫正在行动中--
        cat2.run();//狸花猫正在行动中--
        cat3.run();//一只猫正在行动中--
    }
}

二、Class的继承

关键字：extends

作用：将公共代码抽离出来，实现代码的复用，规范代码

格式：class 类名 extends 被继承的类

函数重写：子函数有一个和父函数（名字，返回值，参数类型，参数数量）都相同的方法

函数重载：子函数有一个和父函数名字相同的方法

调用父函数：super关键字

*final修饰的不可被重写、重载、赋值、继承

*注意类只能继承一个类，也就是父类只能有一个

编写Cat.java

package zhm;

public class Cat extends Animal {
    double weight;
    Cat(String name, double weight){
        //注意super必须在this前
        super(name);//调用父类的构造函数
        this.weight = weight;
    }
    Cat(double weight){
        this.weight = weight;
    }
    Cat(){
        super("流浪猫");
    }
    //函数重写
    @Override
    public void run() {
        System.out.println("猫咪在奔跑--");
    }
    //函数重载
    public void run(String name){
        System.out.println("和"+name+"一起奔跑");
    }
}

实现

package zhm;

public class Main {
    public static void main(String[] args){
        Cat mao1 = new Cat();
        Cat mao2 = new Cat("狸花猫",5);
        mao1.weight = 6;
        mao1.run();//猫咪在奔跑--
        mao2.run(mao1.name);//和流浪猫一起奔跑
    }
}

三、抽象类abstract

关键字：abstract

格式：abstract class 类名

特点：abstract修饰有抽象方法不能被实例（~~new 抽象类~~）

抽象方法：不能有实现体，所继承的类必须重写抽象方法（除非也是抽象类）

*抽象方法必须在抽象类里，抽象类可以有普通类

package zhm;

abstract public class Dog {
    abstract public void eat();
    public void run(){
        System.out.println("它在跑！");
    }
}

四，接口interface

关键字：interface

方式：interface I接口名（命名规范由” I “开头）

特点：属性是常量默认由（public static final）修饰，没有方法实现，必须被重写

继承：implements

继承格式：class 子类 extends 父类 implements 接口1，接口2 {}

*implements必须在extends后

五、修饰符及静态成员

（一）修饰符范围

private: 只能被定义它的类内部使用；

default: 可以内部访问以及同包下的其他类访问；

protected：内部、同包、以及外包的子类访问；

public：内部、同包、外包、其他类；

（二）静态变量和静态函数

修饰符：static

作用：将变量设置为静态变量

*静态函数只能处理静态成员，或者实例的对象

使用格式：

package zhm;

public class Cat extends Animal {
    private static int countCat = 0;
    Cat(String name){
        super(name);//调用父类的构造函数
        this.countCat ++;
    }
    static int getCountCat(){
        return countCat;
    }
}

实例调用：

package zhm;

public class Main {
    public static void main(String[] args){
        Cat mao1 = new Cat("三花猫");
        Cat mao2 = new Cat("狸花猫");
        Cat mao3 = new Cat("奶牛猫");
        System.out.println("你一共创建了"+Cat.getCountCat()+"只猫");//你一共创建了3只猫
    }
}