面向对象编程及其三大特征（JAVA）

• 一.面向对象编程介绍：
• • 面向过程与面向对象：
  • 面向对象的本质：
• 二.面向对象编程的三大特征：
• • 封装：
  • • 封装的概念：
    • 封装的优点：
    • 封装举例（Person类）
  • 继承：
  • • 继承的概念：
    • 继承的优点：
    • 继承类型：
    • 继承注意事项：
    • 继承举例（Animal类）：
  • 多态：
  • • 多态的两种分类：
    • 向上转型：
    • • 为什么要发生向上转型？
    • 向下转型：
    • • 为什么要发生向下转型？

文章目录：

一.面向对象编程介绍：

面向过程与面向对象：

面向过程（Procedure Oriented 简称PO ：如C语言）：
注重过程。当解决一个问题的时候，面向过程会把事情拆分成： 一个个函数和数据（用于方法的参数） 。然后按照一定的顺序，执行完这些方法（每个方法看作一个过程），等方法执行完了，事情就搞定了。

面向对象（Object Oriented简称OO ：如C++，JAVA等语言）：
注重对象。当解决一个问题的时候，面向对象会把事物抽象成对象的概念，就是说这个问题里面有哪些对象，然后给对象赋一些属性和方法，然后让每个对象去执行自己的方法，问题得到解决。

面向对象的本质：

以建立模型体现出来的抽象思维过程和面向对象的方法。

二.面向对象编程的三大特征：

封装：

封装的概念：

封装，即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别。将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。

封装的优点：

• 把对象的私有数据和公共数据分离开，保护了私有数据，减少了可能的模块间干扰，达到降低程序复杂性、提高可控性的目的。
• 清楚的体现了系统之间的松散耦合关系,提高系统的独立性；
• 提高了程序的可复用性和可维护性，降低了程序员保持数据与操作内容的负担。

封装举例（Person类）

//Person类：对Person的属性及方法进行封装，并用private进行私有保护
class Person { 
    private String name;

    private int age;

    public String getName() { 
        return name;
    }

    public int getAge() { 
        return age;
    }

    public Person(String name, int age) { 
        this.name = name;
        this.age = age;
    }

    public String getPersonInfo() { 
        return "姓名:" + this.name + ",年龄:" + this.age;
    }

}

//主类
public class Test { 
    public static void main(String[] args) { 
        //产生Person类的对象p1
        Person p1 = new Person("张三", 18);
        //通过get方法对private方法进行读操作
        System.out.println(p1.getName()+p1.getAge());
        //通过对象调用实例变量与实例方法
        System.out.println(p1.getPersonInfo());
    }
}

执行结果：

张三18
姓名:张三,年龄:18

继承：

继承是面向对象最显著的一个特性。

继承的概念：

继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。

继承的优点：

• 简化代码，提高复用性；
• 增加可维护性；

继承类型：

继承注意事项：

1. 子类不继承其父类的构造方法。

• 当使用无参数的super()时，父类的无参数构造方法就会被调用；
• 当使用带有参数的super()方法时，父类的有参数构造方法就会被调用。

1. 子类继承其父类的所有public和protected成员，但不能继承其父类的private成员。
2. 重写父类中的方法：
   当一个子类中一个实例方法具有与其父类中的一个实例方法相同的签名（指名称、参数个数和类型）和返回值时，称子类中的方法“重写”了父类的方法。
   调用重写方法时，调用的为子类重写的方法。
3. 隐藏父类中的方法：
   如果一个子类定义了一个静态类方法，而这个类方法与其父类的一个类方法具有相同的签名（指名称、参数格式和类型）和返回值，则称在子类中的这个类方法“隐藏”了父类中的该类方法。
   调用隐藏方法时，取决于对象是父类对象的调用还是子类对象的调用
4. 可以在子类中通过使用关键字super()来调用父类中被重写的方法和访问父类中被隐藏的字段。

继承举例（Animal类）：

动物类（公共类，拥有公用的属性和方法）：

public class Animal {  

    public String name;  
    
    public Animal(String name) { 
        this.name = name;
    } 
    public void eat(){  
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){ 
        System.out.println(name+"正在睡");
    }
    public void introduction() {  
        System.out.println("大家好！我是"+ name); 
    } 
}

鸟类：

public class Birld extends Animal {  

    public Birld(String name) {  
        super(name); 
    } 
    public void fly(){ 
        System.out.println(name+"正在飞");
    }
}

狗类：

public class Dog extends Animal {  

    public Dog(String name) {  
        super(name); 
    } 
    public void run(){ 
        System.out.println(name+"正在跑");
    }
}

多态：

相比于封装和继承，Java多态是三大特性中相对更难理解的一个，封装和继承最后归结于多态。

多态的两种分类：

• 重载式多态（方法重载），也叫编译时多态。也就是说这种多态再编译时已经确定好了。重载大家都知道，方法名相同而参数列表不同的一组方法就是重载。在调用这种重载的方法时，通过传入不同的参数最后得到不同的结果。
• 重写式多态（方法重写），也叫运行时多态。这种多态通过动态绑定（dynamic binding）技术来实现，是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。也就是说，只有程序运行起来，你才知道调用的是哪个子类的方法。

这种多态通过函数的重写以及向上转型来实现，我们下面代码中的例子就是一个重写式多态。

向上转型：

Person（父类）：

public class Person { 

    private int money=100;
    
    public void say(){ 
    System.out.println("我是人类");
    }

}

Student（子类）：

public class Student extends Person { 

    private int money=1;

    public void say(){ 
        System.out.println("我是学生");
    }
    
}

Application：

public class Application { 
    public static void main(String[] args) { 
    
        Student student=new Student();
       
        Person p1=new Person();
//多态性的体现
        /* 向上转型 从子到父 父类的引用指向子类的对象 */
        Person p2=new Student();

//成员变量不具有多态性：编译看左边，执行看左边
        System.out.println(p1.getMoney());
        System.out.println(p2.getMoney());
//成员方法具有多态性：编译看左边，执行看右边
        p1.say();//执行父类say方法
        p2.say();//执行子类say方法
    }
}

p2是person的引用，指向了子类Student的对象

成员变量不具有多态性

成员方法具有多态性

故可得到执行结果：

100
100
我是人类
我是学生

为什么要发生向上转型？

• 减少重复代码，使代码变得简洁。
• 提高系统扩展性。
• 用于参数统一化,假设父类有n个子类，方法要接受子类的实例，如果没有向上转型，就需要定义n个方法接收不同的对象。

向下转型：

Person（父类）：

public class Person { 

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

}

Student（子类）：

public class Student extends Person{ 

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

}

Application：

public class Application { 
    public static void main(String[] args) { 
        /* 向上转型 从子到父 父类的引用指向子类的对象 */
        Person obj=new Student();   //高<--低
        obj.run();//此处的run为Student继承person的run();
// obj.go(); //编译报错 父类中无此方法

//--------------------------------------------------------------------------
// student 将这个对象转换为Student类型，我们就可以使用Student的方法了。
        /* 向下转型 从父到子 父亲引用转为子类对象 */
        Student obj1=(Student)obj;   //低<--高
        obj1.go();
// 即为强行转换
// ((Student)obj).go();
//--------------------------------------------------------------------------
        Student obj2=new Student();
        Person person=obj2;                //高<--低 自动转换
// person.go(); //低转高（子类转换为父类）丢失了子类的方法go();
    }
}

运行结果：

run
go

为什么要发生向下转型？

• 当父类需要调用子类的扩充方法时，需要向下转型。
• 一般不操作向下转型，有安全隐患