OOP编程思想：封装、继承、多态

转至：https://zhuanlan.zhihu.com/p/88176396（本人的博客）

面向对象编程（Object-Oriented Programming）与面向过程（Procedure Oriented ）

• 两种方法都是编程中的比较常用的方法，从理论上来说，都能达到用计算机程序来解决实际问题的目的， 只不过是其中所体现出来的思想不一样而已。
• 面向过程：面向过程的思想是把一个项目、一件事情按照一定的顺序，从头到尾一步一步地做下去，先做什么，后做什么，一直到结束。这种思想比较好理解，其实这也是一个人做事的方法。
• 面向对象：面向对象的思想是把一个项目、一件事情分成更小的项目，或者说分成一个个更小的部分，每一部分负责什么方面的功能，最后再由这些部分组合而成为一个整体。这种思想比较适合多人的分工合作，就像一个大的机关，分成各个部门，每个部门分别负责某样职能，各个部门可以充分发挥自己的特色，只要符合一定前提就行了。

面向对象（OOP）的三个特征：

• 封装（Encapsulation）
• 继承（Inheritance）
• 多态（Polymorphism）

一、封装

1、定义：

• Encapsulation in Java is a mechanism of wrapping the data (variables) and code acting on the data (methods) together as a single unit. In encapsulation, the variables of a class will be hidden from other classes, and can be accessed only through the methods of their current class. Java中的封装是一种将数据(变量)和作用于数据(方法)的代码打包为一个单元的机制。在封装中，类的变量将对其他类隐藏，并且只能通过当前类的方法访问。
• Encapsulation can change the internal structure of a class without affecting the overall structure, while protecting the data. For the outside world, its interior is hidden, and what is exposed to the outside world is only the methods that can access it. 封装可以对类的内部进行改变而不影响整体结构，同时也保护来数据。对于外界而言，它的内部是隐藏的，暴露给外界的只是可以访问它的方法。

2、优点：

• 类内部可以自由修改
• 可以对成员变量更准确的控制
• 隐藏信息，保护数据
• 降低耦合度

3、Java的访问控制级别

（1）public：对外公开，级别最高。

（2）protect：只对同一个包中的类或子类公开，级别次之。

（3）默认：只对同一个包中的类公开

（4）private:不对外公开，只能在对象内部访问，级别最低。

例子：

class Demo {
     private String name;
     private String idnum;
     private int age;
      public String getname(){
          return name;
   }
      public void setname(String name){
          this.name=name;
   }
      public String getidnum(){
          return idnum; 
   }
      public void setidnum(String idnum){
          this.idnum=idnum;
   }
      public int getage(){
          return age; 
   }
      public void setage(int age){
          this.age=age;
   }
}
public class Demo{
public static void main(String[] args) {
        Demo demo = new Demo();
        demo.setage(18);
        demo.setname("张三");
        demo.setidnum("123456");
 
        System.out.println("名字为" + demo.getname() + "，年龄为" + demo.getage() + "，学号为" + demo.getidnum());
    }
}

二、继承

public class C extends A{
...
}

1、使用extends关键字。继承允许class继承另一个class的一些通用的fields和methods。多个类存在相同的属性和行为时，定义这么多个类的属性和行为属实有些麻烦，将他们放到单独一个类中就相对比较简洁，只需继承那个定义好属性和行为那个类即可。

• super class ：父类。是哪个可以被别人继承自己的属性的class。
• sub class ：子类。是继承另一个class的属性的class。子类也可以添加自己的fields和methods，也可以覆盖重写（override）父类的方法（不影响父类）。

2、作用：

• 继承提高了代码的重复性
• 继承的出现让类与类之间产生了关系，为多太提供了条件。

3、Java只支持单继承，不允许多继承，即一个子类只能有一个父类，而父类可以有多个子类。

重载（overload）

public class Overloading {
    public int test(){
        System.out.println("test1");
        return 1;
    }
 
    public void test(int a){
        System.out.println("test2");
    }   
 
    //以下两个参数类型顺序不同
    public String test(int a,String s){
        System.out.println("test3");
        return "returntest3";
    }   
 
    public String test(String s,int a){
        System.out.println("test4");
        return "returntest4";
    }   
 
    public static void main(String[] args){
        Overloading o = new Overloading();
        System.out.println(o.test());
        o.test(1);
        System.out.println(o.test(1,"test3"));
        System.out.println(o.test("test4",1));
    }
}

重载方法满足的一些条件：

（1）方法名相同。

（2）方法的参数类型、个数、顺序至少有一项不同。

（3）方法的返回值可以不同。

（4）方法的修饰符可以不同。

方法重写/覆盖（override）：

class Animal{
    public void greeting() {
        System.out.println("Hi, I am a Animal");
    }
}
class Cat extends Animal {
    @Override
    public void greeting() {
        System.out.println("Mome, I am a Cat");
    }
}  
public class Main { 
    public static void main(String args[]) { 
        Animal an = new Animal();
        an.greeting(); //Hi, I am a Animal
        Cat cat = new Cat();
        cat.greeting(); //Mome, I am a Cat
        //顺便看一下runtime 类型的意思 instanceof时提到的
        Animal an2 = new Cat(); 
        //虽然an2是个animal，但是被创建的时候是用Cat class,所以调用cat里的方法
        an2.greeting();//Mome, I am a Cat
    }
} 

覆盖（override）的一些规则：

• method只能在子类里面继承，不能在同一个class里面。
• 子类参数和父类参数一定要一模一样。谁都不能是谁的subclass
• 子类的返回类型要和父类的返回类型一样，或者是父类的返回类型的子类。
• access level 只能越来越大。如果父类是public的，子类只能是public的。如果父类是protected，那子类只能是protected或者public。
• private的方法不能被override。
• 一个加了final的method不能被override。
• 一个加了static的method也不能被overrride。但是可以被重新定义。因为static是class level的。跟子类object没关系。
• 如果子类和父类在同一个包里，子类可以overrride父类的不是private和final的方法。
• 如果子类和父类不在同一个包里，那子类只可以overrride父类public 或者 protected的非final方法。
• 子类可以随意抛出uncheck exceptions，不管父类有没有抛出异常。对于checked exception， 子类抛出的异常需要是父类抛出异常的孩子，或者是抛出比父类少的异常。（narrower or fewer）
• Constructor 不能被 overridde.

重载（overload）与覆盖（override）的区别

总结：

• (1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
• (2)方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
• (3)方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

三、多态

1、多态是指在父类中定义的属性和方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为，这使得同一个属性或方法在父类及其各个子类中具有不同的含义。

2、在Java中有两种体现：

• 方法重载（overload）和覆盖（override）。
• 对象的多态性——可以直接应用在抽象类和接口上。

3、多态存在的三个前提：

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

4、当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

5、多态的定义与使用格式

定义格式：父类类型 变量名=new 子类类型();

多态成员的特点：

（1）多态成员方法：编译看左边，运行看右边

Fu f1=new Zi();
        System.out.println(f1.show());
             //f1的门面类型是Fu,但实际类型是Zi,所以调用的是重写后的方法

6、instanceof关键字

x instanceof A :检验x是否为类A的对象，返回值为boolean型。

• 要求x所属的类与类A必须是子类和父类的关系，否则编译错误。
• 如果x属于类A的子类B，x instanceof A值也为true。

多态案例：

package day0524;
 
public class demo04 {
    public static void main(String[] args) {
        People p=new Stu();
        p.eat();
        //调用特有的方法
        Stu s=(Stu)p;
        s.study();
        //((Stu) p).study();
    }
}
class People{
    public void eat(){
        System.out.println("吃饭");
    }
}
class Stu extends People{
    @Override
    public void eat(){
        System.out.println("吃水煮肉片");
    }
    public void study(){
        System.out.println("好好学习");
    }
}
class Teachers extends People{
    @Override
    public void eat(){
        System.out.println("吃樱桃");
    }
    public void teach(){
        System.out.println("认真授课");
    }

参考资料：

Java基础（多态的理解与应用)

https://blog.csdn.net/qq_41679818/article/details/90523285

百度百科

Java 封装、继承、多态

OOP编程思想：封装、继承、多态

原文：https://www.cnblogs.com/hjdk05/p/12594460.html