CGBTN2108-DAY10总结复习

1.标准类的制作

1.1. 成员变量-属性

使用private进行封装，封装后提供对应的getXxx()与setXxx()

1.2. 构造方法

1.提供一个本类的无参构造
2.提供一个全参构造：创建对象+给对象的所有属性赋值

1.3. 成员方法-普通方法

1.根据本类的业务提供一些方法
2.提供一个方法，用于展现本类的类名以及本类所有属性和属性值

1.4. 创建对象进行测试

1.使用无参构造创建对象，然后调用setXxx()给对象的所有属性赋值
2.使用全参构造创建对象，对象的属性同时也有值

1.5. 练习巩固

需求：创建学生类，按照上述步骤进行测试
学生的属性：学号 姓名 性别 住址 科目
学生的功能：学习 吃饭 睡觉

1.创建学生类Student

package cn.tedu.oop;
/*本类用于描述学生这一类事物*/
public class Student {
    //1.1定义学生的属性
    //1.2 封装学生的属性
    private int id;//学号
    private String name;//姓名
    private char gender;//性别
    private String address;//住址
    private String subject;//科目

    //2.1提供本类的无参构造
    public Student(){
        System.out.println("我是Student的无参构造");
    }
    //2.2提供本类的全参构造
    //右键->Generate->Contructor->Shift全选所有属性->OK
    public Student(int id, String name, char gender, String address, String subject) {
        this.id = id;
        this.name = name;
        this.gender = gender;
        this.address = address;
        this.subject = subject;
        System.out.println("我是Student的全参构造");
    }
    //3.1提供本类的普通方法1
    public void study(){
        System.out.println("学习使我快乐~");
    }
    //3.2提供本类的普通方法2
    public void eat(int n){
        System.out.println("今天我要干它"+n+"碗大米饭");
    }
    //3.3提供本类的普通方法3
    public String sleep(){
        return "今天又睡了美美的一觉";
    }
    //4.提供本类的一个展示类型与所有属性和属性值的方法
    public void show(){
        System.out.println("Student:[id="+id+",name="+name+",gender="+gender+",address="+address+",subject="+subject+"]");
    }

    //1.3提供属性对应的get与set方法
    //右键->Generate->Getter and setter->Shift全选所有属性->OK
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getSubject() {
        return subject;
    }

    public void setSubject(String subject) {
        this.subject = subject;
    }
}

2.创建学生类的测试类TestStudent

package cn.tedu.oop;
/*本类用作学生类的测试类*/
public class TestStudnet {
    public static void main(String[] args) {
        //1.1使用无参构造创建对象
        Student s = new Student();
        //1.2通过setXxx()给对象的所有属性赋值
        s.setId(1);
        s.setName("林冲");
        s.setGender('男');
        s.setSubject("CGB");
        s.setAddress("庙里");
        //1.3通过对象调用方法测试
        s.study();
        s.eat(3);
        System.out.println(s.sleep());
        s.show();//Student:[id=1,name=林冲,gender=男,address=庙里,subject=CGB]

        //2.1使用全参构造创建对象
        Student s2 = new Student(2,"李逵",'男',"猪肉铺","ACT");
        s2.study();
        s2.eat(10);
        System.out.println(s2.sleep());
        s2.show();
    }
}

2. 接口

1.我们通过interface关键字定义接口
2.接口实现类需要通过关键字implements与接口建立实现关系
3.接口不可以创建对象/实例化
4.在Java8中，接口中所有的方法都是抽象方法，方法可以简写，会自动拼接public abstract
5.接口中没有构造方法,接口实现类调用的构造方法是父类的，不是父接口的
注意:如果一个类没有明确指定父类的话，会默认继承顶级父类Object
6.接口中没有成员变量，都是静态常量，默认会拼接public static final
7.接口不是类！！！你可以把接口理解成一个特殊的抽象类，特殊在，所有的方法都是抽象方法
8.如果一个实现类实现了接口，要不变成一个抽象子类【不实现/实现部分】，要不变成一个普通子类【全部实现】
9.接口是用来制定规则的【有哪些方法，方法有参数吗？有返回值类型吗？】，并不做具体的实现
10.接口可以多继承【一个接口可以继承多个接口】 多实现 【一个类可以实现多个接口】

3. 类与类的关系

继承关系，只支持单继承
比如： class A extends B ,A是子类，B是父类，子类具备父类的所有功能

1.子类不能使用父类的私有资源，原因是私有不可见
2.继承相当于子类把父类的功能复制了一份，但是构造方法不可继承
3.子类如果想要在不改变父类功能的前提下，实现功能的修改与拓展，可以重写
重写遵循的原则：两同 两小 一大
注意：方法名+参数列表 称为： 方法签名

4. 接口与接口的关系

继承关系，既可以单继承，也可以多继承
比如：interface A extends Inter1{}
比如：interface B extends Inter,inter2{}
A是Inter1的子接口
B是Inter1与inter2共同的子接口
注意：如果是B的普通实现类
就需要实现B接口以及B接口从Inter1与Inter2接口中继承下来的所有抽象方法

5.类与接口的关系

实现关系，即可以单实现，也可以多实现
比如: class A implements Inter1{ }
比如: class B implements Inter1,Inter2{ }
A是Inter1接口的子实现类
B是Inter1与Inter2接口共同的实现类
注意：B就需要实现Inter1与Inter2接口的所有抽象方法，否则就是一个抽象子类
注意：如果有任何一个抽象方法没有实现，那么这个类一定是一个抽象子类
我们一般创建的都是接口实现类的对象，不用创建多态对象那么麻烦

6. 抽象类与接口的比较

1.抽象类是一个特殊的类，这个类被abstract修饰，并且可以存在抽象方法
接口可以看作是一个特殊的抽象类，接口里面所有的方法都是抽象方法
但是注意：接口不是类，接口使用interface关键字来定义
2.抽象类中有构造方法，但接口中没有构造方法
注意：抽象类的子类调用的就是抽象类的构造，但接口的实现类调用的是自己父类的构造方法
3.抽象类与接口均不可以创建对象
4.接口可以多继承，抽象类只能单继承
5.抽象类中可以定义普通的成员变量，但接口中都是静态常量
6.抽象是后天重构的结果，接口是先天设计的结果