Java面向对象的三大特征

---

面向对象主要由三大特性：

• 封装
• 继承
• 多态

---

一、封装

1. 概念

封装就是利用抽象数据类型（类）将数据和基于数据的操作绑定在一起，数据被保存在抽象数据类型内部，系统只有通过被授权的操作方法才能访问数据。

封装性是面向对象编程的核心思想

特点：
（1）数据和基于数据的操作方阿飞构成一个统一体
（2）类的操作方法实现细节被隐藏起来，只是通过操作接口名称进行调用，操作内部的变动不会影响接口的使用

2. 优点

• 只能通过规定方法访问数据
• 隐藏类实现细节
• 方便修改实现
• 方便加入控制语句

3. 应用

• 修改属性的可见性：public, protected, private, “默认”(无任何修饰符)
• 创建公有的方法用于属性的读写
• 在属性读写方法中加入控制语句，判断属性值的合法性

public class People{
    public String name; // 公有
    protected int age; // 受保护
    char sex; // 默认
    private int money; // 私有

    public int getMoney() { // 公有方法用于属性的读
    	if(money<0) return 0; // 判断属性值的合法性
        return money;
    }
    
    public void setMoney(int money) { // 公有方法用于属性的写
    	if(money<0) this.money = 0; // 判断属性值的合法性
        this.money = money;
    }
}

4. This关键字

• this调用类属性，即类的域变量 / 类字段 / 类数据成员
• this调用本类中的其他方法
• this调用本类中的其他构造方法，调用时要放在构造方法的首行

public class test {
    public int money; // 成员属性 / 类字段
    
    public test(){ // 构造方法1
        this(233);  // this关键字调用类中的其他构造函数
    }

    public test(int a){ // 构造方法2
        this.fun(); // this关键字调用类中的其他方法
        System.out.println(a);
    }
    
    public void fun(){
        this.money = 666; // 使用this关键字给成员属性赋值
        System.out.println(this.money); // 使用this关键字调用类字段
    }
    
    public static void main(String[] args) {
        test myMoney = new test();
    }     
}

输出：

---

二、继承

1. 概念

继承是Java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或类从父类继承方法，使得子类具有父类相同的行为。

2. 特点

• 继承鼓励类的重用
• 继承可以多层继承
• 一个类只能继承一个父类（单继承）
• 父类中private修饰的不能被继承
• 构造方法不能被继承
• 继承的关键字extends

3. 应用

（1）父类

public class Father {
	/*成员属性*/
    public String name; // 公有
    public int age; // 公有
    public char sex; // 公有
    
	/*构造方法*/
	public Father(){
        System.out.println("Father无参构造方法");
    }
    public Father(String name){
        this.name = name;
        System.out.println("Father有参构造方法, Father的名字是："+this.name);
    }
	
	/*成员方法*/
    public void say() { // 公有
        System.out.println("Father会说话");
    }
    public void eat(){ // 公有
        System.out.println("Father会吃饭");
    }    
}

（2）子类访问父类成员属性

访问父类属性：super.name;（可以在其他方法和构造方法中使用）

public class Son extends Father {
    public Son(String name){
        super.name = name; // 给父类成员属性赋值
        System.out.println(super.name); // 访问父类成员属性
    }
    
    public void fun(){
        System.out.println(super.name);
    }
    
    public static void main(String[] args) {
        Son son = new Son("xx");
        son.fun(); // 调用子类fun函数
    }
}

输出：

（3）子类访问父类构造方法

访问父类构造方法：

• 父类无参的构造方法：super();
• 父类有参的构造方法：super(name);

注意：访问父类的构造函数只能在子类的构造函数中访问，且必须是子类构造函数的第一行

public class Son extends Father {
    public Son(){
        super("**"); 
    }
    
    public static void main(String[] args) {
        Son son = new Son();
    }
}

输出：

（4）子类访问父类方法

访问父类方法：super.方法名();

public class Son extends Father {
    public Son(String name){
        super.eat(); // 访问父类的eat方法    
    }
    
    public void fun(){
        super.say(); // 访问父类的say方法
    }
    
    public static void main(String[] args) {
        Son son = new Son("xx");
        son.fun(); // 调用子类fun函数
    }
}

输出：

总结super关键字：

1. super 只能出现在子类的方法和构造方法中
2. super 调用构造方法时，只能是第一句
3. super 不能访问父类的 private 成员

4. 继承的限制

不能被继承的父类成员：

• private成员
• 子类与父类不在同包，使用默认访问权限的成员
• 构造方法

5. 多重继承初始化顺序

6. 方法的重写

• 在子类中可以根据需要对父类中继承来的方法进行重写
• 重写的方法和被重写的方法必须具有相同方法名称、参数列表和返回类型
• 重写方法不能使用被重写的方法

public class Son extends Father {
    public void say(){ // 子类方法重写
        System.out.println("Son会说英语");
        super.say();
    }
    
    public static void main(String[] args) {
        Son son = new Son();
        son.say();
    }
}

输出：

---

三、多态

1. 概念

多态是指一个程序中同名的不同方法共存的情况。

Java中提供两种多态的机制：重载（Overloading）与覆盖（Overriding）

2. 实现思路

（1）编写父类
（2）编写子类，子类重写父类方法
（3）运行时，使用父类的类型，子类的对象

3. 实现多态的三个必要条件

• 继承
• 重写
• 父类引用指向子类对象

public class Son extends Father {
    public void say(){ // 子类方法重写
        System.out.println("Son会说英语");
    }
    
    public static void main(String[] args) {
    	Father father = new Father();
        father.say();
        System.out.println();
        
        Father fatherson = new Son();
        fatherson.say();
        System.out.println();
        
        Son son = new Son();
        son.say();
    }
}

输出：

4. 重载

方法名相同，参数类型或个数不同。
注意：若方法名相同，参数相同，返回类型不同，则编译不通过。

class Parent {
	public int getScore() {
		return 3;
	}
	public int getScore() {
		return i;
	}
}

5. 覆盖

子类对父类的同名方法（方法名相同，参数相同，返回类型相同）重新进行定义，即在子类中定义与父类中已定义的同名而内容不同的方法。

class Parent {
	public int getScore() { return 3; }
	public String getCountryName() { return "China"; }
}

class Son extends Parent {
	public int getScore() { 
		return 4; 
	}
	public void function() {
		System.out.println(super.getScore());
	}
	public static void main(String[] args){
		Son s = new Son();
		System.out.println(s.getScore());
		System.out.println(s.getCountryName());
		s.function();
	}
}

输出：

6. 重载和覆盖的区别

函数名	参数	返回值	static	多态
同	不同	同/不同		重载
同	同	同		覆盖
同	同	同	不同	不同函数
同	同	不同		编译不通过