Java的面向对象三大特征（封装、继承、多态）

面向对象的三大特征

封装

• 该露的露，该藏的藏
  • 我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
• 封装（数据的隐藏）
  • 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
• 记住这句话就够了：属性私有，get/set

封装的意义

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

例：

package object;

public class FengZhuang {

    private String name; // 姓名
    private int age; // 年龄
    private char sex; // 性别  char只能输入一个字 （男、女）

    // get 可以获取
    public String getName() {
        return name;
    }

    // set 可以给变量赋值
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        // 判断输入年龄是否合法
        if (age < 0 || age > 130){
            this.age = 3;
        }else{
            this.age = age;
        }
    }

    public char getSex() {
        return sex;
    }

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

package object;

public class FengZhuangtest {
    public static void main(String[] args) {
        FengZhuang fz = new FengZhuang();

        // fz.setAge(999);因为上面的判断，如果输入不合法就直接返回 3
        fz.setAge(12);// age年龄赋值
        System.out.println(fz.getAge());// 12

        fz.setSex('男');// sex性别赋值
        System.out.println(fz.getSex());// 男

        fz.setName("木子");// name姓名赋值
        System.out.println(fz.getName());// 木子
    }
}

继承（extends）

[Ctrl + H]可以看继承的关系

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模

• extands的意思是“扩展”。子类是父类的扩展

• JAVA中类只有单继承，没有多继承！

• 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合聚合等。

• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。

• 子类和父类之间，从意义上讲应该具有“is a”的关系

• object类

• super

• 方法重写

---

• 实例：

//在Java中，所有的类，都默认为直接或者间接继承object
// 父类
public class Person{
    
    public int money = 10_0000_0000;
    
    // 私有的子类是不可以调用的   
    // 默认是default
    // String fu = "father";
    private String fu = "father";
    
    public void say(){
        System.out.println("说了一句话");
    }
    
    // 不过我们可以 get/set 去用fu方法
    public String getFu(){
        return fu;
    }
    public String setFu(){
        this.fu = fu
    }
}

// 派生类/子类
// 子类继承了父类，就会拥有父类的全部方法
public class Student extends Person {
    
}
// 派生类/子类
public class Teacher extends Person {
    
}


public static void main(String[] args){
    Student s = new Student();
    s.say();// 输出：说了一句话
    System.out.println(s.money);// 1000000000
}

super：以图为例

上图可以看到，super可以调用父类的所有字段，但是父类中使用了private的字段，方法，属性都不可以调用。

---

---

super注意点

1. super 调用父类的构造方法，必须在构造方法的第一个
2. super 必须只能出现在子类的方法或构造方法中！
3. super 和 this 不能同时调用构造方法

Vs this:

• 代表对象不同：
  • this：本身调用者这个对象
  • super：代表父类对象的应用
• 前提：
  • this：没用继承也可以使用
  • super：只能在继承条件下才可以使用
• 构造方法：
  • this()：本类的构造
  • super()：父类的构造

---

方法的重写

// 没有重写
// 继承
public class A extends B{
    public static void test(){
        System.out.println("A=>test()");
    }
}
// 重写都是方法的重写，和属性无关
public class B{
    public static void test(){
        System.out.println("B=>test()");
    }
}

public static void main(String[] args){
    // 方法的调用只和左边，定义的数据类型有关
    A a = new A();
    a.test();// A=>test()
    
    // 父类的引用指向了子类
    B b = new A();
    b.test();// B=>test()
}

// 有重写
// 继承
public class A extends B{
    public void test(){
        System.out.println("A=>test()");
    }
}
// 重写都是方法的重写，和属性无关
public class B{
    
    // Override 重写
    @Override // 注解：有功能的注释！
    public void test(){
        System.out.println("B=>test()");
    }
}

// 静态方法和非静态方法区别很大！
// 静态方法：// 方法的调用只和左边，定义的数据类型有关
// 非静态： 重写
// 重写的关键词只能是public
public static void main(String[] args){
    
    A a = new A();
    a.test();// A=>test()
    
    // 父类的引用指向了子类
    B b = new A();// 子类重写了父类的方法
    b.test();// A=>test()
}

• 总结：
  • 重写：需要有继承关系，子类重写父类的方法！
    1. 方法名必须相同
    2. 参数列表列表必须相同
    3. 修饰符：范围可以扩大：private<Default<protected<public
    4. 抛出的异常：范围可以被缩小，但不能扩大；ClassNotFoundException --> Exception(大)
  • 重写，子类的方法和父类必须要一致；方法体不同！
  • 为什么需要重写：
    1. 父类的功能，子类不一定需要，或者不一定满足！

多态

• 动态编译：类型；可扩展性

• 即同一个方法可以根据发送对象的不同而采用多种不同的行为方式。

• 一个对象的实际类型是确定的，但可以指向对象的引用类型有很多。

• 多态存在的条件

  • 有继承关系
  • 子类重写父类方法
  • 父类引用指向子类对象

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

• instanceof（类型转换）引用类型，判断一个对象时是什么类型

• 实例；

public static void main(String[] args){
    // 一个对象的实例类型是确定的
    // new Student();
    // new Person();
    
    // 可以指向的引用类型就不确定了：父类的引用指向子类
    Student s1 = new Student();
    Person s2 = new Student();
    Object s3 = new Student();
    
    // 对象能执行那些方法，主要看对象左边的类型，和右边关系不大！
    s2.run();// 输出run
    // 子类重写了父类的方法，执行子类的方法
    ((Student)s2).eat();// 这里进行了强制转换
    s1.eat();
}

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

public class Student extends Person{
    @Overrid
    public void run(){
        System.out.println("son");
	}	
    
    public void eat(){
        System.out.println("eat");
    }
}

多态注意事项：

1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系 不然会有类型转换异常！ClassCastException！
3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象！ father f1 = new Son();

• static 方法，属于类，它不属于实例
  （无法重写）
• final 常量；（无法重写）
• （无法重写）private方法；

instanceof 和 类型转换

实例

public static void main(String[] args){
    
    // Object > String
    // Object > Person > Teachar
    // Object > Person > Student
    Object object = new Student();
    
    System.out.println(object instanceof Student);// true
    System.out.println(object instanceof Person);// true
    System.out.println(object instanceof Object);// true
    System.out.println(object instanceof Teacher);// false
    System.out.println(object instanceof String);// false
    System.out.println("===========================================");
    Person person = new Student();
    System.out.println(person instanceof Student);// true
    System.out.println(person instanceof Person);// true
    System.out.println(person instanceof Object);// true
    System.out.println(person instanceof Teacher);// false
    //System.out.println(person instanceof String);// 编译错误
    System.out.println("===========================================");
    Student student = new Student();
    System.out.println(student instanceof Student);// true
    System.out.println(student instanceof Person);// true
    System.out.println(student instanceof Object);// true
    //System.out.println(student instanceof Teacher);// 编译错误
    //System.out.println(student instanceof String);// 编译错误
    
    System.out.println("------------------------------------------------");
    
    //类型之间的转换：父      子
    
    // 子类转换为父类。可能丢失自己的本来的一些方法！
    Student student = new Student();
    student.go();
    Person person = student;
    
    //高                低
    Person obj = new Student();
    ((Student)obj).go();// 强制转换
}

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

public class Student extends Person{
    public void go(){
        System.out.println("go");
    }
}

public class Teacher{
    
}

static 关键字详解

// static 
public class Student{
    private static int age;// 静态的变量
    private double score;// 非静态变量
    
    public void run(){
        
    }
    public static void go(){
        
    }
    
    public static void main(String[] args){
        Student s1 = new Student();
        System.out.println(s1.age);
        System.out.println(Student.age);
        //System.out.println(Student.score);// 报错
    	
        go();
        //run();// 报错
    }
}

public class Person{
    {// 可以赋初始值
        // 代码快（匿名代码块）
        System.out.println("匿名代码块");
    }
    // static 只执行一次
    static {
        // 静态代码块
        System.out.println("静态代码块");
    }
    
    public Person(){
        System.out.println("构造方法");
    }
    
    public static void main(String[] args){
        Person p = new Person();
        System.out.println("===========");
        Person p2 = new Person();
    }
}

• 输出
  • 静态代码块
  • 匿名代码块
  • 构造方法
  • ===========
  • 匿名代码块
  • 构造方法

---

import static java.lang.Math.tandom;
import static java.lang.Math.PI;

public class Test{
    public static void main(String[] args)
    {
        System.out.println(random());
        System.out.println(PI);
    }
}
// 通过 final 修饰的类 就不能被继承