面向对象编程三大特征

面向对象编程有三大特征：封装、继承和多态。

封装：

1.封装介绍：

封装(encapsulation)就是把抽象出的数据[属性]和对数据的操作[方法]封装在一起，数据被保护在内部；程序的其它部分只有通过被授权的操作[方法],才能对数据进行操作。

2.好处：

1)隐藏实现细节：方法(连接数据库)<--调用(传入参数…)

2)可以对数据进行验证，保证安全合理

3.实现步骤：

1)将属性进行私有化private 【不能直接修改属性】

2)提供一个公共的(public)set方法，用于对属性判断并赋值

public void setXxx(类型参数名){}

3)提供一个公共的(public)get方法，用于获取属性的值public数据类型

getXxx(）{//权限判断，Xxx某个属性，return xX}

4.细节：

（1）封装基本需要定义属性，构造方法，get和set方法。

（2）在构造方法中，除了使用this关键字引用当前对象的实例变量，还可以使用定义的set方法。

（3）在测试类中，创建对象时用定义的set方法或构造方法来设置对象的信息。

代码示例：

package Fengzhuang;

/**
 * @Author: 911
 * @Description:
 * 不能随便查看人的年龄,工资等隐私，并对设置的年龄进行合理的验证。
 * 年龄合理就设置，否则给默认 年龄, 必须在 1-120,
 * 年龄， 工资不能直接查看 ， name 的长度在 2-6 字符 之间
 * @Date Created in 2024-01-26 15:09
 * @Modified By:
 */
public class Anli01 {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("jack");
        person.setAge(300);
        person.setSalary(30000);
        System.out.println(person.info());
        System.out.println(person.getSalary());
        //如果我们自己使用构造方法指定属性
        Person smith = new Person("smith", 80, 50000);
        System.out.println("====smith 的信息======");
        System.out.println(smith.info());
    }


}

//只有 默认和 public 可以修饰类
class Person {
    public String name;
    private int age;
    private double salary;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        if (name.length() >= 2 && name.length() <= 6) {
            this.name = name;
        } else {
            System.out.println("名字的长度不对，需要(2-6)个字符，默认名字");
            this.name = "无名人";
        }
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        //年龄, 必须在 1-120
        if (age >= 1 && age <= 120) {//如果是合理范围
            this.age = age;
        } else {
            System.out.println("你设置年龄不对，需要在 (1-120), 给默认年龄 18 ");
            this.age = 18;//给一个默认年龄
        }
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String info() {
        return "信息为 name=" + name + " age=" + age + " 薪水=" + salary;
    }

    public Person() {
    }

    public Person(String name, int age, double salary) {
//        this.name = name;
//        this.age = age;
//        this.salary = salary;
        //我们可以将 set 方法写在构造器中，这样仍然可以验证
        setName(name);
        setAge(age);
        setSalary(salary);
    }
}

---

继承：

1.基本介绍：

  继承可以解决代码复用 , 让我们的编程更加靠近人类思维 . 当多个类存在相同的属性 ( 变量 ) 和方法时 , 可以从这些类中 抽象出父类,在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过 extends 来 声明继承父类即可。

示意图：

2.基本语法：

class 子类 extends 父类{}

1)子类就会自动拥有父类定义的属性和方法

2)父类又叫超类，基类。

3)子类又叫派生类。

3.好处：

1) 代码的复用性提高了

2) 代码的扩展性和维护性提高了

4.细节：

1) 子类继承了所有的属性和方法， 非私有 的属性和方法可以在子类直接访问 , 但是 私有 属性和方法不能在子类直接访 问，要通过父类提供公共的方法去访问

2) 子类必须调用父类的构造器， 完成父类的初始化

3) 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用 super 去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过

4) 如果希望指定去调用父类的某个构造器，则显式的调用一下 : super( 参数列表 )

5) super 在使用时，必须放在构造器第一行

6) super() 和 this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器

7) java 所有类都是 Object 类的子类 , Object 是所有类的基类 .

8) 父类构造器的调用不限于直接父类！将一直往上追溯直到 Object 类 ( 顶级父类 )

9) 子类最多只能继承一个父类 ( 指直接继承 ) ，即 java 中是单继承机制。

思考：如何让 A 类继承 B 类和 C 类？ 【 A 继承 B ， B 继承 C 】

10) 不能滥用继承

5.继承的本质：

在编写代码时，要注意按照查找关系来返回信息。

(1) 首先看子类是否有该属性

(2) 如果子类有这个属性，并且可以访问，则返回信息

(3) 如果子类没有这个属性，就看父类有没有这个属性 ( 如果父类有该属性，并且 可以访问 ，就返回信息 ..)

(4) 如果父类没有就按照 (3) 的规则，继续找上级父类，直到 Object...

6.两个小案例：

案例一：

package extend_.exercise;

/**
 * @Author: Sober.911
 * @Description:
 * @Date Created in 2024-01-28 16:56
 * @Modified By:
 */
public class exercise01 {
    public static void main(String[] args) {
        B b = new B();
    }
}
class A{
    A(){
        System.out.println("a");
    }
    A(String name){
        System.out.println("a name");
    }
}
class B extends A{
    B(){
        this("abc");
        System.out.println("b");
    }
    B(String name){
        //super();默认调用父类的无参构造器
        System.out.println("b name");
    }
}

 在Main中， B b=new B();会输出什么？

解释：首先调用B的无参构造方法，执行到this("abc");时调用B自身的带字符串的构造方法。在此构造方法中默认调用其父类A的无参构造方法，之后执行System.out.println("b")。

因此输出结果为a, b name, b

案例二：

public class ExtendsExercise02 {

        public static void main(String[] args) {

                C c = new C();

        }

}

class A {//A 类

        public A() {

                System.out.println("我是 A 类 ");

        }

}

class B extends A { //B 类 , 继承 A 类

        public B() {

                System.out.println("我是 B 类的无参构造 ");

        }

        public B(String name) {

                System.out.println(name + "我是 B 类的有参构造 ");

        }

}

class C extends B {

//C 类，继承 B 类

        public C() {

                this("hello");

                System.out.println("我是 c 类的无参构造 ");

        }

        public C(String name) {

                super("hahah");

                System.out.println("我是 c 类的有参构造 ");

        }

}

在Main中，   C c = new C();会输出什么？

结果：

我是A类，hahah我是B类的有参构造，我是C类的有参构造，我是C类的无参构造

this关键字：

注意事项和使用细节：

1) this 关键字可以用来访问本类的属性、方法、构造器

2) this 用于区分当前类的属性和局部变量

3) 访问成员方法的语法： this. 方法名 ( 参数列表 );

4) 访问构造器语法： this( 参数列表 ); 注意只能在构造器中使用 ( 即只能在构造器中访问另外一个构造器 , 必须放在第一 条语句)

5) this 不能在类定义的外部使用，只能在类定义的方法中使用

super关键字：

1.基本介绍：

super 代表父类的引用，用于访问父类的属性、方法、构造器

2.基本语法：

1.访问父类的属性，但不能访问父类的private属性  super.属性名；

2.访问父类的方法，不能访问父类的private方法     super.方法名(参数列表);

3.访问父类的构造方法:     super(参数列表);只能放在构造器的第一句，只能出现一句!

4.super 的访问不限于直接父类。

5.  如果多个父类 中都有同名的成员，使用 super 访问遵循就近原则。

super和this的比较：

方法重写/覆盖(override)：

1.基本介绍：

简单的说：方法覆盖(重写)就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法

2.注意事项和使用细节：

（1）子类的方法的形参列表，方法名称，要和父类方法的形参列表，方法名称完全一样。

（2）子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类。比如父类返回类型是Object,子类方法返回类型是String

（3）.子类方法不能缩小父类方法的访问权限  public>protected >默认>private

重写与重载的比较：

 

多态： 

1.基本介绍：

方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的。

重写与重载体现多态

2.对象的多态 (核心，困难，重点)

(1)一个对象的编译类型和运行类型可以不一致

(2)编译类型在定义对象时，就确定了，不能改变

(3)运行类型是可以变化的.

(4)编译类型看定义时=号的左边，运行类型看=号的右边

3.多态注意事项和细节讨论

多态的前提是：两个对象(类)存在继承关系

多态中的上转型与下转型特别重要

上转型：

1)本质：父类的引用指向了子类的对象

2)语法：父类类型 引用名=new子类类型0;

3)特点：编译类型看左边，运行类型看右边。可以调用父类中的所有成员(需遵守访问权限),不能调用子类中特有成员；最终运行效果看子类的具体实现!

下转型：

1)语法：子类类型 引用名= (子类类型)交类引用

2)只能强转父类的引用，不能强转父类的对象

3)要求父类的引用必须指向的是当前目标类型的对象

4)当向下转型后，可以调用子类类型中所有的成员

package Poly;

/**
 * @Author: 911
 * @Description:
 * @Date Created in 2024-01-29 15:57
 * @Modified By:
 */
public class Animal {
    String name = "动物";
    int age = 10;

    public void sleep() {
        System.out.println("睡");
    }

    public void run() {
        System.out.println("跑");
    }

    public void eat() {
        System.out.println("吃");
    }

    public void show() {
        System.out.println("hello,你好");
    }
}

package Poly;

/**
 * @Author: 911
 * @Description:
 * @Date Created in 2024-01-29 15:58
 * @Modified By:
 */
public class Cat extends Animal {
    @Override
    public void eat() {//方法重写
        System.out.println("猫吃鱼");
    }

    public void catchMouse() {//Cat 特有方法
        System.out.println("猫抓老鼠");
    }

}
package Poly;

/**
 * @Author: 911
 * @Description:
 * @Date Created in 2024-01-29 16:26
 * @Modified By:
 */
public class Dog extends Animal{

}
package Poly;

/**
 * @Author: 911
 * @Description:
 * @Date Created in 2024-01-29 15:59
 * @Modified By:
 */
public class PolyDetail {
    public static void main(String[] args) {
        //向上转型: 父类的引用指向了子类的对象!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        //语法：父类类型引用名 = new 子类类型();
        Animal animal = new Cat();
        Object obj = new Cat();//可以吗? 可以 Object 也是 Cat 的父类
        //向上转型调用方法的规则如下:
        //(1)可以调用父类中的所有成员(需遵守访问权限)
        //(2)但是不能调用子类的特有的成员
        //(3)因为在编译阶段，能调用哪些成员,是由编译类型来决定的
        //animal.catchMouse();错误
        //(4)最终运行效果看子类(运行类型)的具体实现, 即调用方法时，按照从子类(运行类型)开始查找方法
        //，然后调用，方法调用规则一致。
        animal.eat();//猫吃鱼.. animal.run();//跑
        animal.show();//hello,你好
        animal.sleep();//睡
        //希望，可以调用 Cat 的 catchMouse 方法
        //多态的向下转型
        //(1)语法：子类类型 引用名 =（子类类型）父类引用;
        //问一个问题? cat 的编译类型 Cat,运行类型是 Cat
        Cat cat = (Cat) animal;
        cat.catchMouse();//猫抓老鼠
        //(2)要求父类的引用必须指向的是当前目标类型的对象!!!!!!!!!!!!!!!!!!!!!!!!!!!
        //Dog dog = (Dog) animal; //可以吗？
    }
}

注意： 

属性没有重写之说！属性的值看编译类型

代码示例：

package PolyDetail02;

/**
 * @Author: 911
 * @Description:属性没有重写之说！属性的值看编译类型
 * @Date Created in 2024-01-29 17:41
 * @Modified By:
 */
public class Detail02 {
    public static void main(String[] args) {
//属性没有重写之说！属性的值看编译类型
        Base base = new Sub();//向上转型
        System.out.println(base.count);// ？ 看编译类型 10
        Sub sub = new Sub();
        System.out.println(sub.count);//? 20
    }
}

class Base { //父类
    int count = 10;//属性
}

class Sub extends Base {//子类
    int count = 20;//属性
}

instanceOf 比较操作符

用于判断对象的运行类型是否为 XX 类型或 XX 类型的子类型

代码示例：

package PolyDetail03;

/**
 * @Author: 911
 * @Description:instanceOf 比较操作符，
 * 用于判断对象的运行类型是否为 XX 类型或 XX 类型的子类型
 * @Date Created in 2024-01-29 17:43
 * @Modified By:
 */
public class Detail03 {
    public static void main(String[] args) {
        BB bb = new BB();
        System.out.println(bb instanceof BB);// true
        System.out.println(bb instanceof AA);// true
        //aa 编译类型 AA, 运行类型是 BB
        //BB 是 AA 子类
        AA aa = new BB();
        System.out.println(aa instanceof AA);
        System.out.println(aa instanceof BB);
        Object obj = new Object();
        System.out.println(obj instanceof AA);//false
        String str = "hello";
        //System.out.println(str instanceof AA);
        System.out.println(str instanceof Object);//true
    }
}
class AA{

}
class BB extends AA{

}