面向对象程序三大特性：封装、继承、多态

面向对象程序三大特性：封装、继承、多态

一、面向对象

1. 什么是面向对象

   面向对象是一种符合人类思维习惯的编程思想。在现实生活中，人们倾向于将不同的事物进行分类，将具有类似属性的事物归为一类，方便记忆与理解。在程序中，通过对象来映射现实生活中的事物，使用对象间的关系来描述事物间的关系，我们便将这种思想称为面向对象。 面向对象编程因其关注的是对象，而非过程，这使得其可以更加灵活和便于理解。使用不同的对象去处理不同的事物，在处理问题时可以通过不同的对象相互协调，快速灵活地完成功能的开发。同时，如果相应的规则改变了，仅仅需要修改对应的对象即可，便于开发和维护。

2. 面向对象与面向过程

   面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步步实现， 使用的时候一个一个依次调用就可以了;面向对象是把构成问题的事物分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

   如：洗衣服

   面向过程：步骤：①收集脏衣服 ②把脏衣服放盆里，倒洗衣液 ③揉搓 ④清水洗 ⑤拧干 ⑥晾衣服

3. 面向对象：对象：人，衣服，洗衣机，洗衣液

   步骤：①把衣服放进洗衣液 ②倒入洗衣液 ③启动洗衣机，洗衣机就会自动清洗并甩干

   面向过程注重的是洗衣服的过程，面向对象注重的是对象，即把对象衣服交给对象洗衣机即可。

二、三大特性

1. 封装

   1.1 概念

   将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。简单说就是套壳屏蔽细节。

   1.2 访问限定修饰符

   范围	private	default	protected	public
   同一包中的同一类	√	√	√	√
   同一包中的不同类		√	√	√
   不同包中的子类			√	√
   不同包中的非子类				√

   • private：同一类可访问

   • default:：默认权限，同一个包中可访问

   • protected：同一个包及不同包中的子类可访问，主要是用在继承中

   • public：都可以看得到

   1.3 get，set方法

   class Students{
   
       //封装第一步：将变量私有化，加private关键字
       private int id;//
       private String name;//
   
       //封装第三步：在public修饰的构造方法中，调用set方法进行合理值判断
       public Students() {
       }
   
       public Students(int id, String name) {
           //this.id = id;
           //this.name = name;
           setId(id);
           setName(name);
       }
   
       //封装第二步：提供public修饰的get和set方法
       public int getId() {
           return id;
       }
   
       public void setId(int id) {
           if(id>1900&&id<2000){
               this.id = id;
           }else{
               System.out.print("学号输入有误，请检查！");
           }
       }
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       //打印学生学号和姓名
       public void show(){
           //System.out.println("学号为"+id+"的学生姓名是"+name);
           System.out.println("学号为"+getId()+"的学生姓名是"+getName());
       }
   
   }
   class StudentsTest{
       public static void main(String[] args) {
   
           Students student1=new Students();//new一个对象
           //对成员变量进行赋值
           //student.id=1905;
           //student.name="hy";
           student1.setId(1905);
           student1.setName("hy");
           student1.show();//打印
   
           Students student2=new Students(1906,"hw");
           student2.show();
   
           Students student3=new Students(1750,"hf");
           student3.show();
   
       }
   }

   

2. 继承

   2.1 概念

   继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。

   2.2 语法

   修饰符 class 子类 extends 父类 {
   
   // 代码
   
   }

   2.3 super关键字

   作用：在子类方法中访问父类的成员。

   super.data;//调用父类的成员变量
   
   super.func();//调用父类的成员方法
   
   
   
   super();//调用父类的构造方法
   
   //注：①必须是子类构造函数的第一条语句 ②不能和this同时出现

3. 多态

   3.1 概念

   通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

   3.2 满足条件：

   1. 必须在继承体系下

   2. 子类必须要对父类中方法进行重写

   3. 通过父类的引用调用重写的方法

   3.3 重写与重载

   方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

   区别点	重载(override)	重写(override)
   参数列表	必须修改	一定不能修改
   返回类型	可以修改	一定不能修改
   访问限定修饰符	可以修改	一定不能做更严格的限制（可以降低限制）
   异常	可以修改	可以减少或删除，一定不能抛出新的或者更广的异常

   • 重写

     1. 概念

        重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非fifinal修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

     2. 代码

        public abstract class PerimeterArea {
            static final float PI=3.14F;
            public abstract float getPerimeter();
            public abstract float getArea();
        }
        public class Circle extends PerimeterArea {
            private float radius;  //半径
            public Circle(float radius){
                this.radius=radius;
            }
            
            @Override
            public float getPerimeter(){  //重写父类方法
                return 2*PI*radius;
            }
            @Override
            public float getArea(){  //重写父类方法
                return PI*radius*radius;
            }
        }

   • 重载

     1. 概念

        在Java中，如果多个方法的名字相同，参数列表不同，与返回值类型是否相同无关，则称该几种方法被重载了。

     2. 代码

        class OverLoadTest{
            public static int add(int a,int b){
                return a+b;
            }
            public static double add(double a,double b){
                return a+b;
            }
            public static int add(int a,int b,int c){
                return a+b+c;
            }
        ​
            public static void main(String[] args) {
                System.out.println(add(3,5));
                System.out.println(add(2.4,5.2));
                System.out.println(add(1,3,5));
            }
        }