【Java】面向对象一：肝完今天的10p，感觉自己又行了-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_51517498/article/details/129133016

面向对象

本质

以类的方式组织代码，以对象的方式封装数据

三大特性

封装：将数据包装起来，需要留一个口取出

继承

多态

break跳出循环，return出现方法就结束了，

static方法在创建类的时候就已经加载进去了，如果用static类调用非static类，会报错。

构造器

1.和类名相同

2.没有返回值

作用：

1.new在调用构造方法

2.初始化对象的值

注意：

1.定义了有参构造之后，如果要用无参构造，需要显示定义无参构造

alt+insert可以生成构造器

构造器举例：

package com.yolanda.OO.demo02;

public class Person {
    String name;
    int age;

    //自动生成的
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //默认会生成这个类
    /*
    1.使用new关键字，本质是在调用构造器
    2.用来初始化值
     */
//    默认就是什么都不干
    public Person(){
    }
//    有参构造：一旦定义有参构造，无参就必须显示定义

    public Person(String name){
        this.name=name;
    }

}
//alt+insert生成构造器

类里面只有属性和方法

封装

高内聚：内部细节由自己完成，低耦合：仅暴露少量的方法给外部使用！

意义：

1.提高安全性，保护数据

2.隐藏代码的实现细节

3.统一接口

4.提高可维护性，便于修改内部信息

package com.yolanda.OO.demo04;

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
//        s1.name;由于是私有属性所以不能直接调用
        s1.setName("Yolanda");
        System.out.println(s1.getName());
        s1.setAge(999);
        System.out.println(s1.getAge());
    }
}

package com.yolanda.OO.demo04;

public class Student {
    private String name;
    private int id;
    private char sex;
    private int age;

//    私有属性，需要一些set，get方法
//    alt+insert

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public char getSex() {
        return sex;
    }

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

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

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age>120){
            this.age=3;
        }else{
            this.age = age;
        }
    }
}

继承

本质是对类的抽象

extends是对类的扩展

子类可以继承父类的所有方法

ctrl+H可以看到继承树

在java中，所有的类都默认继承object类

java只有单继承，没有多继承：一个儿子只能有一个爸爸，但是一个爸爸能有多个儿子。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dWCV35Ax-1676902526433)(C:\Users\Yolanda Y\AppData\Roaming\Typora\typora-user-images\image-20230220211245576.png)]

Person类：父类

package com.yolanda.OO.demo05;

public class Person {
    //private东西无法继承，要想调用需要get set方法
    //default
    //protected受保护的

    //ctrl+H 可以看到继承树
    //在java中，所有的类都默认继承object类

    private int money=1000000;

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public void say(){
        System.out.println("say something");
    }
}

Student类：子类

package com.yolanda.OO.demo05;

//子类继承父类，会拥有父类的所有方法
public class Student extends Person{
}

Application应用类

package com.yolanda.OO.demo05;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
        System.out.println(student.getMoney());

    }
}

super修饰符

1.用来调用父类的对象

2.必须只能出现在子类的方法或者构造方法中

3.super和this不能同时调用构造方法

super与this的比较

1.代表的对象不同

this：本身调用这个对象

super：代表父类对象的应用

2.前提

this：吴继承也能使用

super：只有在继承条件才能使用

3.构造方法

this（）：调用本类的构造

super（）：父类的构造

package com.yolanda.OO.demo06;

public class Student extends Person{
    public Student() {
        //隐藏代码：调用父类的无参构造器，必须要在子类构造器的第一行
//        super();//这个只能在代码第一行

        //想要写子类的无参构造器，必须要创建父类的无参构造器
        System.out.println("Student类无参执行了");
    }

    private String name="Yangjia";

    public void test(String name){
        System.out.println(name);//这里是形参的name，也就是方法本身括号内传进去的name
        System.out.println(this.name);//这里是当前类：Student类中的name
        System.out.println(super.name);//这个是父类Person类中的name
    }
}

package com.yolanda.OO.demo06;

public class Student extends Person{
    public Student() {
        //隐藏代码：调用父类的无参构造器，必须要在子类构造器的第一行
//        super();//这个只能在代码第一行

        //想要写子类的无参构造器，必须要创建父类的无参构造器
        System.out.println("Student类无参执行了");
    }

    private String name="Yangjia";

    public void test(String name){
        System.out.println(name);//这里是形参的name，也就是方法本身括号内传进去的name
        System.out.println(this.name);//这里是当前类：Student类中的name
        System.out.println(super.name);//这个是父类Person类中的name
    }
}

package com.yolanda.OO.demo06;

public class App {
    public static void main(String[] args) {
        Student student = new Student();
        student.test("我的名字");

    }
}

重写Override

重写是方法的，和属性无关

前提：需要有继承关系，而且是子类重写父类的方法！

1.方法名必须相同

2.参数列表必须相同

3.修饰符：范围可以扩大，但是不能缩小

public>protected>default>private

4.抛出的异常：范围可以被缩小，但是不能扩大

子类的方法与父类方法必须一致，方法体不同

为什么需要重写：

父类的功能，子类不一定需要，或者不一定满足

alt+insert：override

package com.yolanda.OO.demo07;

public class B {
    public static void test(){
        System.out.println("B test");
    }
}

package com.yolanda.OO.demo07;

public class A extends B{
    @Override
    public int hashCode() {
        return super.hashCode();
    }

    public static void test(){
        System.out.println("A test");
    }
}

package com.yolanda.OO.demo07;

public class App {
    public static void main(String[] args) {
        //静态方法：方法的调用只和左边的有关
        //非静态：重写！而且只能是public的方法，和引用的对象有关，和左边的没关系
        A a = new A();
        a.test();

        //父类的引用指向了子类
        B b = new A();
        b.test();
    }
}