Java基础知识整理系列第三弹

最新推荐文章于 2022-09-29 11:24:52 发布

诗与远方_阿范

最新推荐文章于 2022-09-29 11:24:52 发布

阅读量479

点赞数 1

分类专栏： JavaSE吐血整理系列文章标签： java 多态抽象类接口类

本文链接：https://blog.csdn.net/weixin_46098676/article/details/117197979

版权

JavaSE吐血整理系列专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一、对象和类

（1）类的概念
属性—对象具有的各种特征
方法—对象执行的操作
具有相同或者相似性质的对象的抽象就是类，类就是一个模型，确定对象拥有的属性和方法。
（2）对象的概念
对象是类的一个具体实例。
（3）类和对象的关系
类是对一类事物的抽象，是对象的类型
对象是实际存在的个体，是类的实例化
（4）创建类的对象
先肯定抽象出来对象的属性和方法，然后通过new关键字创建类的对象。
（5）动手案例
例1: 编写一个整数计算器，具备加、减、乘、除、求余、平方等功能

class  Calc{
    //计算器
    public   double calc(int x, int y, String s) {
        if (s.equals("*")) {
            return x * y;
        } else if (s.equals("/")) {
            return x / y;
        } else if (s.equals("+")) {
            return x + y;
        } else if (s.equals("-")) {
            return x - y;
        } else if (s.equals("%")) {
            return x % y;
        } else if (s.equals("+")) {
            return x + y;
        } else if (s.equals("2")) {
            return x*x + y*y;
        } else {
            return 0;
        }
    }
}
public class Test01 {
    public static void main(String[] args) {
        Calc c=new Calc();
        double result=c.calc(10,20,"*");
        System.out.println(result);
    }
}

二、封装：就是属性私有化，但是要提供公有访问私有属性的方法。

例2：
（1）具有属性：名称（title）、页数（pageNum），其中页数不能少于200页，否则输出错误信息，并赋予默认值200
（2）具有方法： detail，用来在控制台输出每本教材的名称和页数。
（3）具有带参数的构造方法：用来完成对象的初始化工作，并在构造方法中完成对页数的最小值限制
（4）编写测试类Book2Test进行测试：初始化一个Book2对象，并调用该Book2对象的detail方法，看看输出是否正确

public class Book {
    //属性私有
    private String title;
    private int  pageNum;
    //带参数的构造方法
    public  Book(String title, int pageNum){
        this.title = title;
        if(pageNum>=200){
            this.pageNum = pageNum;
        }else{
            this.pageNum = 200;
            System.out.println("页数不能小于200页");
        }
    }
   //get 和 set 方法
    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public int getPageNum() {
        return pageNum;
    }

    public void setPageNum(int pageNum) {
        this.pageNum = pageNum;
    }
    //公有的方法
    public void detail(){
        System.out.println("教材的名称为："+title+"\t"+"教材的页数为："+pageNum);
    }
}

测试函数（程序入口）

public class Book2Test {
    public static void main(String[] args) {
        Book b= new Book("数学",20);
        b.detail();
    }
}

三、方法的重载

重载方法必须满足以下条件：
（1）方法名相同（2）方法的参数类型、个数、顺序至少有一个不相同（3）方法的返回类型、修饰符可以不相同
例3：
（1）具有属性：名称（title）、页数（pageNum）、种类（type）
（2）具有方法：detail，用来在控制台输出每本教材的名称、页数、种类
（3）具有两个带参构造方法：第一个构造方法中，设置教材种类为“计算机”（固定），其余属性的值由参数给定；第二个构造方法中，所有属性的值都由参数给定
（4）分别以两种方式完成对两个Book3对象的初始化工作，并分别调用它们的detail方法，看看输出是否正确

public class Book {
    //属性私有
    private String title;
    private int  pageNum;
    private  int type;
    //带参数的构造方法
    public  Book( int pageNum,int type){
        this.type=type;
        this.pageNum=pageNum;
        this.title="计算机";
    }
    public  Book( String title,int pageNum,int type){
        this.type=type;
        this.pageNum=pageNum;
        this.title=title;
    }
    //get 和 set 方法
    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public int getPageNum() {
        return pageNum;
    }

    public void setPageNum(int pageNum) {
        this.pageNum = pageNum;
    }

    public int getType() {
        return type;
    }

    public void setType(int type) {
        this.type = type;
    }

    //公有的方法
    public void detail(){
        System.out.println("教材的名称为："+title+"\t"+"教材的页数为："+pageNum+"\t"+"教材的种类为："+type);
    }
}

测试函数（程序入口）

public class Book3Test {
    public static void main(String[] args) {
        //第一种构造
        Book b1=new Book(20,20);
        b1.detail();
        //第二种构造
        Book b2= new Book("数学",20,20);
        b2.detail();
    }
}

四、继承

继承：将几个类甚至更多类，提取公共的属性和方法，定义一个父类，其他类继承父类公共的属性和方法，然后可以增加新的成员变量和方法。
方法的重写要满足以下条件：
（1）子类和父类的方法具有相同的名称、参数列表、返回值类型
（2）方法重写只存在于子类和父类（包括直接父类和间接父类）之间，在同一个类中的方法只能被重载，不能被重写
注意：
父类中的private、final修饰的方法不能被重写
子类方法不能缩小父类方法的访问权限
子类方法不能抛出比父类方法更多的异常
Super关键字
子类可以通过super关键字调用父类的构造方法
注意：super必须位于构造方法的第一句
Object为所有类的祖宗，继承只能继承一个父类

例4：
动物（Animal）具有行为：吃（eat）、睡觉（sleep）
动物包括：兔子（Rabbit），老虎（Tiger）
这些动物吃的行为各不相同（兔子吃草，老虎吃肉）；但睡觉的行为是一致的。
并编写测试类AnimalTest进行测试。

父类（动物）

public class Animal {
    //吃
    public void  eat(){
        System.out.println("动物们吃东西");
    }
    //睡觉
    public void sleep(){
        System.out.println("动物们在睡觉");
    }
}

兔子类

public class Rabbit extends Animal {

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

    @Override
    public void sleep() {
        super.sleep();
    }
}

老虎类

public class Tiger extends Animal {
    @Override
    public void eat() {
        System.out.println("老虎吃肉");
    }

    @Override
    public void sleep() {
        super.sleep();
    }
}

测试函数（程序入口）

public static void main(String[] args) {
   Rabbit r= new Rabbit();
   r.eat();
   r.sleep();
   Tiger t =new Tiger();
   t.eat();
   t.sleep();
}

五、多态

多态：一个东西具有多种形态的能力。
例如：同一台打印机，既可以打印黑白，又可以打印彩印，这就是打印机的多态。
子类重写父类的方法，子类根据实际需要，对父类的方法进行添加。创建对象时动态决定使用那个方法。
多态的表现形式
方法的重载
方法的重写

六、常量

常量是一种标识符，用final修饰，它的值在运行期间恒定不变
被final修饰的变量为常量
被final修饰的方法不能被重写
被final修饰的类不能被继承

七、抽象类

包含了抽象方法的类，称为抽象类。
抽象类里面的抽象方法没有任何方法体，子类若为普通类要实现父类的所有抽象方法。子类若为抽象类，可以重写父类的抽象方法，也不可以重写。
抽象类一般当做父类被子类继承。
抽象类可以包含抽象方法和普通方法。

八、接口

接口是一种“纯抽象类”，不提供实现，基本数据类型的数据成员，默认为public，statistic和final。
利用接口设计类的过程，称为接口的实现，使用implements关键字。
接口可以多重继承，允许一个类可以实现多个接口，通过这种机制可实现多重继承。

例 USB接口

// interface 接口
public interface USB {

    // 接口中的属性默认被public static final修饰
    static final int USB_MEMORY = 128;

    // 接口中的方法必须是抽象方法
    // 接口中的方法默认被public abstract修饰
    void transferData();

    public void saveData();

    public void charge();
    
}

实现类
三星u盘

public class Samsung implements USB {
    @Override
    public void transferData() {
        System.out.println("三星在传输数据");
    }

    @Override
    public void saveData() {
        System.out.println("三星在存储数据");
    }

    @Override
    public void charge() {
        System.out.println("三星在充电");
    }
}```
金士顿u盘

```java
// Kingston 接口的实现类
public class Kingston implements USB{
    @Override
    public void transferData() {
        System.out.println("金士顿在传输数据");
    }

    @Override
    public void saveData() {
        System.out.println("金士顿存储数据");
    }

    @Override
    public void charge() {
        System.out.println("金士顿在充电");
    }
}

u盘可以实现多个接口，但是都需要实现所有接口中的抽象方法。
例金士顿u盘

// interface 接口
public interface USB {

    // 接口中的属性默认被public static final修饰
    static final int USB_MEMORY = 128;

    // 接口中的方法必须是抽象方法
    // 接口中的方法默认被public abstract修饰
    void transferData();

    public void saveData();

    public void charge();

}

接口A

public interface A {
    public void a();
}

实现类（金士顿u盘）

//一个类可以实现多个接口，但是必须重写(实现)所有接口中的抽象方法
public class Kingston implements USB,A{
    @Override
    public void transferData() {
        System.out.println("金士顿在传输数据");
    }

    @Override
    public void saveData() {
        System.out.println("金士顿存储数据");
    }

    @Override
    public void charge() {
        System.out.println("金士顿在充电");
    }
//接口A的实现
    @Override
    public void a() {
    }
}