Java面向对象学习笔记

前言：笔记是参考B站up主遇见狂神说，图片、代码都是哦。因为最近特别喜欢他教的课程，所以就一边跟着学习，一边在blog写笔记~（图片、代码来源狂神说Java，侵权必删！）
狂神说Java学习路线B站网站：https://www.bilibili.com/read/cv5702420

构造器

有参构造：一旦定义了有参构造，无参构造就必须显示定义

构造器：

1. 和类名相同
2. 没有返回值

作用：

1. new本质在调用构造方法
2. 初始化对象的值

封装（属性私有 get/set）

1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 系统可维护增强了

class Student{
    //属性私有private
    private int id;
    private String name;
    private String sex;

    //使用get、set提供给外界使用
    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 String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

继承（私有的东西无法继承，java类中只有单继承！没有多继承！！）

1. 子类继承了父类，就会拥有父类的全部方法
2. 在java中，所有的类都默认直接继承Object（老祖宗类）
3. extends是扩展的意思，子类是父类的扩展
4. 隐藏代码，调用了父类的无参构造。super();父类构造器，必须在子构造器第一行
5. super和this不能他同时调用构造方法

this和super注意点：

1. 代表对象不同；this本身调用自己这个对象；super代表父类对象的应用
2. this没有继承也可以使用；super只能在继承条件才可以使用
3. this()本类的构造方法；super()父类的构造方法

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();//由于学生继承了Person，所以可以使用Person类的方法！
    }
}

class Student extends Person{
    //学生继承了Person
}

class Person {
    public void say(){
        System.out.println("说了一句话");
    }
}

多态（有继承关系、子类重写父类方法、父类引用指向子类对象）

• 注意：多态是方法的多态，属性没有多态性

以下解释转载至：https://www.cnblogs.com/xjhere/p/5842461.html

要理解多态性，首先要知道什么是“向上转型”。

我定义了一个子类Cat，它继承了Animal类，那么后者就是前者是父类。我可以通过 Cat c = new Cat(); 实例化一个Cat的对象，这个不难理解。

但当我这样定义时： Animal a = new Cat();

表示定义了一个Animal类型的引用，指向新建的Cat类型的对象。由于Cat是继承自它的父类Animal，所以Animal类型的引用是可以指向Cat类型的对象的。

那么这样做有什么意义呢？因为子类是对父类的一个改进和扩充，所以一般子类在功能上较父类更强大，属性较父类更独特， 定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。

所以，父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，它是无可奈何的； 同时，父类中的一个方法只有在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用； 对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接。也可以叫做动态绑定。

动态绑定是指”在执行期间（而非编译期间）“判断所引用对象的实际类型，根据实际的类型调用其相应的方法。

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();//由于学生继承了Person，所以可以使用Person类的方法！

        //父类的引用指向了子类！
        Person person = new Student();
        person.say();
    }
}

class Student extends Person{
    public void say(){
        System.out.println("子类重写了父类的say()方法！");
    }
}

class Person {
    public void say(){
        System.out.println("说了一句话");
    }
}

向上转型： Person p = new Student() ; //向上转型不需要强制类型转化
向下转型： Student student = (Student)new Person() ; //必须强制类型转化

抽象类（抽象类不能被new出来，只能靠子类去实现它，单继承！只有接口可以多继承）

1. abstract，抽象方法只有方法名字，没有方法的实现
2. 抽象类中可以写普通方法
3. 抽象方法必须在抽象类中
4. 抽象类的所有方法，子类必须要去实现它的方法，除非这个子类也是抽象的

public class Application {
    public static void main(String[] args) {
        //抽象类不能被new出来！
    }
}

//定义抽象类
abstract class Action {
    //定义抽象方法
    public abstract void doSomething();
}

接口

1. interface定义的关键字
2. 接口需要实现类！！！
3. 接口中的所有定义其实都是抽象的
4. 类可以实现接口 implements 接口
5. 实现了接口的类，就必须重写接口中的方法
6. 接口可以实现多继承，一个类可以继承多个接口
7. 抽象不能被实例化！因为抽象，接口中没有构造方法！！！

public class Application {
    public static void main(String[] args) {
        //
    }
}

//interface定义接口,接口需要实现类！！！
interface UserService {
    //定义接口的方法
    void add(int no,String name,String sex);
    void delete(int no);
}

//第二个接口
interface TimeService{
    void getTime();
}

//实现类；接口实现类可以多继承接口！
class UserServiceImpl implements UserService,TimeService{
    //必须重写接口的方法！
    @Override
    public void add(int no, String name, String sex) {
        //方法体
    }

    @Override
    public void delete(int no) {
        //方法体
    }

    @Override
    public void getTime() {
        //方法体
    }
}

重写

1. 需要有继承关系，子类重写父类的方法
2. 方法名必须相同
3. 参数列表必须相同
4. 修饰符，范围可以扩大但不能缩小：public>protected>default>private
5. 重写，子类的方法和父类要一致；方法体不同
6. 为什么要重写？：父类的功能，子类不一定需要，或者不一定满足

注意：

1. 静态（static）方法不能被重写，只有非静态才可以重写
2. final常量和private方法都不能重写，一旦被final父类就不可能被继承
3. 没有重写就没有多态！

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();//由于学生继承了Person，所以可以使用Person类的方法！
    }
}

class Student extends Person{
    public void say(){
        System.out.println("子类重写了父类的say()方法！");
    }
}

class Person {
    public void say(){
        System.out.println("说了一句话");
    }
}