Java面向对象概述及三大特征（封装，继承和多态）

一、面向对象思想

Java是面向对象的高级语言，对于Java语言来说，万事万物皆对象！

它的基本思想是使用类，对象，继承，封装，消息等基本概念进行程序设计。面向对象程序的最小单元是类，类代表了客观世界中具有某一特征的一类事物，封装了这类事物所具有的属性和行为。

所以，类定义=成员变量（属性）+方法（行为）。

面向对象程序设计与人类的思维习惯一致，比如希望完成“兔子吃草"这件事：

在面向过程的程序设计里，一切以函数为中心，则会用如下语句来表达：

吃（兔子，草）；

而在面向对象程序设计里，一切以对象为中心，则会用如下语句来表达：

兔子.吃（草）；

对比这两条语句可以看出，面向对象语句更接近自然语言语法，主谓宾一目了然。

二、类与对象的关系

　　类是对象的抽象，对象则是类的实例，一个类可以生成多个对象。对一个类定义而言，包含三种最常见的成员：构造器、成员变量和方法，而构造器是一个类创建对象的根本途径，如果一个类没有构造器则无法创建实例。因此，如果程序员没有为一个类创建构造器，则系统会为该类提供一个默认无参的构造器。下面定义一个简单的Person类：

public class Person{    //定义两个成员变量：姓名和年龄
    public String name;    public int age;    //定义一个say方法
    public void say(String content){
        System.out.println(content);
    }
}

　　定义类之后就可以通过Person p = new Person()来创建对象了，Person对象赋给了p变量，它们在内存中的存储示意图如下：

三、面向对象的三个基本特征（封装，继承和多态）

1、封装

 封装是指将对象的实现细节隐藏起来，对外提供公共访问方法，将对象的功能暴露出来。

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

适当的封装可以让程式码更容易理解与维护，也加强了程序代码的安全性。最终目的是实现模块设计的”高内聚低耦合“。

那么，如何实现java的封装呢？首先来看一下java的访问控制级别：

Java提供了4个访问控制级别，由小到大如下图：

从上图可以得出，实现一个类封装的步骤如下：

 修改属性的可见性（访问级别）来限制对属性的访问（一般限制为private），例如：

/**这段代码中，将 name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。 
*/public class Person {    private String name;//姓名
    private int age;//年龄}

 　　  对每个值属性提供对外的公共方法访问，也就是创建一对赋值取值的方法，用于对私有属性的访问，例如：

public class Person{    private String name;    private int age;    public int getAge(){      return age;
    }    public String getName(){      return name;
    }    public void setAge(int age){      this.age = age;
    }    public void setName(String name){      this.name = name;
    }
}

　　采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突，this指当前对象。

因此，一个类定义时，一般用private修饰成员变量，public修饰成员方法。获取成员变量应该用对象.get变量名()而不是对象.成员变量名。

2、继承

　　我们生活中有很多继承的例子：如兔子属于动物的一种，兔子有一般动物的特征及行为，在java语言里可以说兔子继承动物，兔子是子类，动物是父类；学生和老师都属于人类，有人的一般特性，所以在java语言里可以说学生和老师继承人类。所以继承需要符合的关系是：is-a，父类更通用，子类更具体。

 继承是指子类可以复用父类的属性和方法，Java的继承是单继承，每个子类只有一个直接父类。Java的继承通过extends关键字实现，实现继承的类称为子类，被继承的类称为父类（基类或超类）。Java继承语法格式如下：

修饰符 class SubClass extends SuperClass{  //类定义部分      }

　　需要注意的是 Java 不支持多继承，但支持多重继承。

　　子类包含与父类同名方法的现象称为方法重写，也称为方法覆盖。

　　方法的重写要遵循“两大两小一大”规则，“两同”即方法名相同、形参列表相同；“两小”指子类方法返回值类型应该比父类方法返回值类型要小或相等，子类方法声明抛出的异常应该比父类方法声明抛出的异常类要小或相等；“一大”指子类方法的访问权限应比父类方法的访问权限更大或相等。

3、多态

　　多态是指子类对象可以直接赋给父类变量（父类引用指向子类对象），但运行时依然表现出子类的行为特征，也就是说，同一类型的对象在执行同一个方法时，可能表现出多种行为特征。

　  多态存在的三个必要条件

• 继承

• 重写

• 父类引用指向子类对象

　　比如：Parent p = new Child();

　　当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

　　多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

　　下面举一个多态的例子：

public class Test {    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
} 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

执行以上程序，输出结果为：

吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠

原文出处：https://www.cnblogs.com/bingyimeiling/p/10232605.html