Java面向对象-5-CSDN博客

本文链接：https://blog.csdn.net/weixin_47059164/article/details/134297759

什么是面向对象

方法的定义

类和对象的创建

封装

public class Student {
    //属性
    //私有属性
    private String name;
    private int id;
    private int age;
    //使用get/set方法可以对属性设置值
    public String getName(){
        return this.name;
    }
    public void setName(String name){
        this.name = name;
    }

    public int getId() {
        return id;
    }

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

    public int getAge() {
        return age;
    }
    //可以安全规避
    public void setAge(int age) {
        if (age>150||age<0){
            System.out.println("错误");
        }else{
            this.age = age;
        }
    }
}

好处

1、隐藏代码细节，提高安全性，保护数据

2、统一接口规范，可维护性高

3、可以进行安全规避

继承

方法重写：

        //A是子类，B是父类
        A a = new A();//重写前，A的方法
        a.test();
        B b = new A();//重写前，B的方法，重写后A的方法
        b.test();

继承语法：

public class Student extends Person{
//私有的无法被继承
}

1、super调用父类的构造方法，必须在构造方法的第一个
2、super必须只能出现在子类的方法或者构造方法中
3、super和this不能同时调用构造方法
Vs this
    代表的对象不同:
        this:本身调用者这个对象
        super:父类对象
     前提:
        this：没继承也可以使用
        super：只能在继承条件下才可以使用
     构造方法:
        this();本类的构造
        super();父类的构造
     若是父类定义了有参构造器，并且无参构造器没有显式定义，则无法调用父类的无参构造器
    只能调用父类的有参，也无法定义子类的无参，所以定义有参构造器之后要把无参写上，
 */

多态

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

package demo02;
import demo02.A;
public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        new Student();
        new Person();
        //可以指向的引用类型就不确定了：父类的引用指向子类
        Student s1 = new Student();
        //父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();
        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
        ((Student)s2).eat();
        s1.eat();
    }
}

注意事项：
1、多态是方法的多态，属性没有多态
2、有父子类关系的才可以进行转换
3、多态存在的条件，有继承关系，方法进行重写 Father F1=new Person（），父类的引用指向子类的对象，低--->高不需要强转，不过可能会遗失方法，高--->低要强转。
static private final修饰的无法进行重写

class Animal {
    public void move() {
        System.out.println("动物可以移动");
    }
}
 
class Dog extends Animal {
    @Override
    public void move() {
        System.out.println("狗可以跑和走");
    }
    public void bark() {
        System.out.println("狗可以吠叫");
    }
}
 
class TestDog {
//  形参类型只写一种Animal即可，如果没有向上转型，要写Dog，Fish，Cat等多种形参，那就累死了。
    public static void doEat(Animal h) {
        h.move();
    }
    public static void main(String args[]) {
        Animal a = new Animal(); // Animal 对象
// 下一行就是向上转型，需要Animal，给个Dog，也行吧，但是不能执行Dog类的特有方法了。
        Animal b = new Dog(); 
// 下一行需要Dog，给它Animal，肯定不行，编译出错！
//        Dog d =new Animal();  
        Dog c = new Dog();
        a.move();// 执行 Animal 类的方法
        b.move();//执行 Dog 类的方法
//        b.bark()  该方法使用失败
        c.bark();
//下两行体现了向上转型的精髓，假如没有向上转型，面对不同的实参，形参要写很多种，那样该方法要写多少个呀！！！！
        doEat(new Dog()); //狗可以跑和走
        doEat(new Animal()); //动物可以移动
    }
}