Java面向对象的三大特征

Java 面向对象的三大特征

面向对象主要有三大特性：封装、继承、多态

一、封装

1、封装的概念
　　封装性是面向对象编程的核心思想，指的就是将描述某种实体的数据和基于这些数的操作集合到一起，形成一个封装体。
　　封装的思想保证了类内部数据结构的完整性，使用户无法轻易直接操作类的内部数据，这样降低了对内部数据的影响，提高了程序的安全性和可维护性。
2、封装的好处：
　　只能通过规定方法访问数据；
　　隐藏类数实现细节；
　　方便修改实现；
　　方便加入控制语句。
3、封装的使用
　　1）修改属性的可见性 ——> 设为private
　　2）创建共有的 getter / setter方法 ——> 用于属性的读写
　　3）在getter / setter方法中加入属性控制语句 ——> 对属性值的合法性进行判断

public class Demo1 {

    public String name;        // 公有的
    protected int age;        // 受保护的
    char sex;                // 默认的
    private int num;        // 私有的
    
    /**
     * 获取私有成员num值
     * @return
     */
    private int getNum() {
        return num;
    }
    
    /**
     * 设置私有成员num的值
     * @param num
     */
    private void setNum(int num) {
        this.num = num;
    }
}

4、this关键字
this关键字主要有三个应用：
this调用本类中的属性，也就是类中的成员变量；
this调用本类中的其他方法；
this调用本类中的其他构造方法，调用时要放在构造方法的首行。

public class Demo2 {

    public int num;
    public Demo2(){
        this(1);                	// this关键字调用类中的其他构造函数
    }
    
    public Demo2(int a){
        this.fun();                // this关键字调用类中的其他方法
        System.out.println(a);
    }
    
    public void fun(){
        this.num = 100;            //使用this关键字给成员属性赋值
        System.out.println(this.num);
    }
    
    public static void main(String[] args) {
        Demo2 demo2 = new Demo2();
    }   
}

二、继承

1、继承的概念和特点
概念：
　　继承是Java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。
　　继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或类从父 类继承方法，使得子类具有父类相同的行为。
特点：
　　继承鼓励类的重用；
　　继承可以多层继承；
　　一个类只能继承一个父类；
　　父类中private修饰的不能被继承；
　　构造方法不能被继承。
2、使用继承
1）编写父类
有公共的属性和方法：

/**
 * 父类
 */
public class Father {

    //父类中的成员属性
    public String name;    
    public int age;
    public char sex;
    
    /**
     * 父类中的成员方法
     */
    public void say(){
        System.out.println("我会说话");
    }
    
    public void eat(){
        System.out.println("我会吃饭");
    }    
}

2）编写子类，继承父类
a.子类继承父类时只能继承一个父类
b.继承的关键字：extends

/**
 * 子类只能继承一个父类
 * 关键字：extends
 */
public class Son extends Father { 
    
}

3、子类访问父类成员
访问父类构造方法：
super();　父类无参的构造方法
super(name); 父类有参的构造方法
访问父类属性：
　 super.name;
访问父类方法：
　 super.方法名();
首先定义一个父类，父类有成员属性，成员发方法，无参构造方法，有参构造方法

//首先定义一个父类，父类有成员属性，成员发方法，无参构造方法，有参构造方法
/**
 * 父类
 */
public class Father {

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

a.访问父类构造方法

public class Son extends Father {

    /**
     * 访问父类构造方法 
　　　* super();　父类无参的构造方法
     * super(name);   父类有参的构造方法    
     */
    public Son(){
        super("**");     //必须注意：访问父类的构造函数只能在子类的构造函数中访问，且必须是子类构造函数的第一行
    }
    
    public static void main(String[] args) {
        Son son = new Son();
    }
}

控制台打印的结果为：我是有参的构造方法,我的名字是：**
b.访问父类属性

public class Son extends Father {

    /**
     * 访问父类属性
　　　* super.name;    //可以在其他方法和构造方法中使用
     */
    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函数
    }
}

控制台打印的结果为：
　　我是无参的构造方法
　　xx
　　xx
c.访问父类方法

public class Son extends Father {

    /**
     * 访问父类方法
　　　* super.方法名();    //可以在其他方法和构造方法中使用
     */
    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、方法的重写
　　在子类中可以根据需要对父类中继承来的方法进行重写；
　　重写的方法和被重写的方法必须具有相同方法名称、参数列表和返回类型；
　　重写方法不能使用被重写的方法更严格的访问权限。

public class Father {
    /**
     * 父类中的成员方法
     */
    public void say(){
        System.out.println("我会说话");
    }

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

在子类中重写：

public class Son extends Father {
    
    /**
     * 一个跟父类方法一样的方法
     */
    public void say(){
        System.out.println("我会说英语");
    }
    
    public static void main(String[] args) {
        Son son = new Son();
        son.say();
    }
}

控制台打印结果：我会说英语
son.say()方法首先会去父类找say方法，如果子类没有重写say()方法，就会输出 “我会说话” ；但是子类里面也有say()方法，就会把父类的say()方法重写，输出子类中say()方法的内容。

三、多态

1、多态的概念
生活中的多态：
不同类型的打印机打印效果不同
黑白打印机　　黑白纸张
打印机
彩色打印机　　彩色纸张　　　　
程序中的多态 ：父类引用，子类对象
同一种事物，由于条件不同，产生的结果也不同
多态：同一个引用类型，使用不同的实例而执行不同操作
　　将父类对象应用于子类对象的特征就是面向对象编程中的多态性的体现。
　　多态指的就是在应用程序中出现的“ 重名 ” 现象。多态性允许以统一的风格编写程序，以处理种类繁多的已存在的类及其相关类。这样既降低了维护难度，又节省了时间
2、使用多态实现思路
　　编写父类
　　编写子类，子类重写父类方法
　　运行时，使用父类的类型，子类的对象
3、实现多态的三个必要条件：
　　继承
　　重写
　　父类引用指向子类对象

public class Father {
    
    /**
     * 父类中的成员方法
     */
    public void say(){
        System.out.println("我会说话");
    }
}

重写：

public class Son extends Father {
    
    /**
     * 一个跟父类方法一样的方法
     */
    public void say(){
        System.out.println("我会说英语");
    }
}

在Java语言中，多态性主要表现在以下几个方面：
　　方法重写
　　抽象类
　　接口