Java面向对象的三大特性

面向对象的三个主要特征

• 封装性：是保护内部的结构不直接被外部可见，提高安全性的
• 继承性：在已有基础上继续进行扩充
• 多态性：在一个合理的范围之内进行有限的变化，是整个项目的灵魂

---

封装性

-封装性是面向对象编程中的三大特征之一,封装性就是把对象的成员属性和成员方法结合成一个独立的相同单位，并尽可能隐蔽对象的内部细节，包含如下两个含义：
①把对象的全部成员属性和全部成员方法结合在一起，形成一个不可分割的独立单位（即对象）
②信息隐蔽，即尽可能隐蔽对象的内部细节，对外形成一个边界，只保留有限的对外接口是指与外部发生联系。

封装的意义：

封装的意义在于保护或者防止代码（数据）被我们无意中破坏。在面向对象程序设计中数据被看作是一个中心的元素并且和使用它的函数结合的很密切，从而保护它不被其它的函数意外的修改。

######1. 保护数据成员，不让类以外的程序直接访问或修改，只能通过提供的公共的接口访问<==>对数据的封装。

######2. 方法的细节对用户是隐藏的，只要接口不变，内容的修改不会影响到外部的调用者<==>对方法的封装。

######3. 当对象含有完整的属性private int id；和 与之对应的方法 public int getId(){};时称为封装。

######4. 从对象外面不能直接访问对象的属性，只能通过和该属性对应的方法访问。

#####5. 对象的方法可以接收对象外面的消息

####没有被封装的对象
######对象中的成员属性如果没有被封装，一旦对象创建完成，就可以通过对象的引用获取任意的成员属性的值，并能够给所有的成员属性任意赋值。在对象的外部任意访问对象中的成员属性时是非常危险的，因为对象中的成员属性时对象本身具有的与其他对象不同的特征，是对象某个方面性质的表现。例如：“电话”的对象中有一些属性值是保密技术，是不想让其他人随意能获取到的，所以它的权限是私有的 private。在”电话”对象中的电压和电流等属性的值，需要规定在一定的范围内，是不能被随意修改、随意赋值的。如果对这些属性赋一些不合乎规范的值，譬如说手机的电压赋上380V的值，就会破坏手机对象。
######对象中的成员方法如果没有被封装，就可以在对象的外部随意调用，但这是一种非常危险的操作。因为对象中的成员方法只有部分是给外部提供的。保留有限的对外接口使之与外部发生联系。而有一些是对象自己使用的方法。例如，在”人”的对象中，提供了”走路”的方法，而”走路”的方法又是通过在对象内部调用”迈左腿”和” 迈右腿”两个方法组成。如果用户在对象的外部直接调用” 迈左腿”或” 迈右腿”的方法就没有意义，没有考虑到人这个对象，应该只让用户（人）能调用”走路”的方法。
######封装的原则就是要求对象以外的部分不能随意存入和读取对象的内部数据(成员属性和成员方法).从而有效地避免了外部错误对它的”交叉感染”,使软件错误能够局部化，大大较少出现BUG的程度，程序员很清楚，太多需要调试的BUG，无异于在敲一遍自己写的代码。

###代码

import java.util.Date;
/*
 - 封装性 
 */
public class User {
	private int id;
	private String username;
	private Date birthday;
	private String sex;
	private String address;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	
	public Date getBirthday() {
		return birthday;
	}
	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
}

一个类作为整体对象不可见，并不代表他的所有域和方法也对程序其他部分不可见，需要有他们的访问修饰符判断。

访问修饰符	本类	同包	不同包，子类	不同包，非子类
public	√	√	√	√
private	√
protected	√	√	√
默认	√	√

---

继承性##

-“继承”是面向对象软件技术当中的一个概念。如果一个类A继承自另一个类B，就把这个A称为"B的子类"，而把B称为"A的父类"。继承可以使得子类具有父类的各种属性和方法，而不需要再次编写相同的代码。在令子类继承父类的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类的原有属性和方法，使其获得与父类不同的功能。
#####***继承性是子类继承了其父类不是private的成员变量作为自己的成员变量，并且继承了父类中不是private的方法作为自己的方法，继承的成员变量或方法的访问权限保持不变。***#####
######继承的限制：a.子类继承父类全部的操作，公共操作直接继承，私有操作通过其他方式访问。b.一个子类只能继承一个父类，属于单继承的方式。c.可以多层继承的（类A的功能是a，B的功能是b，C具有功能a，b，C就不用在编写a，b，继承A,B就行了）######
######子类对象的实例化：对于子类的构造方法而言，隐含了一条super()语句，super从子类调用父类的构造方法，默认的是调用父类中的无参数构造方法，super放在构造方法的首行。**this 和 super 调用构造方法的语句不可能同时出现。
###代码

public class Animals{
	public int id;
	public String name;
	public Animals(){
		this.id = 3;
		this.name = "xx";
	}
	public static void main(String[] args){
		Dog d = new Dog();
		System.out.println(d.id);
	}
}
class Dog extends Animals{
	public int id;
	public String name;
	public Dog(){
	}
}

---

多态性

在面向对象的程序设计理论中，多态性的定义是：同一操作作用于不同的类的实例，将产生不同的执行结果，即不同类的对象收到相同的消息时，得到不同的结果。多态是面向对象程序设计的重要特征之一，是扩展性在“继承”之后的又一重大表现 。对象根据所接受的消息而做出动作，同样的消息被不同的对象接受时可能导致完全不同的行为，这种现象称为多态性。
|— 多态性包含编译时的多态性、运行时的多态性两大类。 即：多态性也分***静态多态性***和***动态多态性***两种。
####静态多态性
|—静态多态性是指定义在一个类或一个函数中的同名函数，它们根据参数表（类型以及个数）区别语义，并通过静态联编实现，例如，在一个类中定义的不同参数的构造函数。
####动态多态性
|—动态多态性是指定义在一个类层次的不同类中的重载函数，它们一般具有相同的函数，因此要根据指针指向的对象所在类来区别语义，它通过动态联编实现。
######|—在用户不作任何干预的环境下，类的成员函数的行为能根据调用它的对象类型自动作出适应性调整，而且调整是发生在程序运行时，这就是程序的动态多态性。即，发出同样的消息被不同类型的对象接收时，有可能导致完全不同的行为。
#####|—就是有存有多种状态，同名但有区别，java里面的元素只要有区别就会有多态，比如变量，他在同一个函数的不同位置可以同名吧，还有函数名，很显然，这个就是多态了，说的复杂一点，就是你要实现一个相同的功能，但又有不同，比如返回，即结果不同，尽管输入不同，但有个相同的名字，这就是多态了，也指父类的某个方法被子类重写时，可以各自产生自己的执行方法。
####多态的三个条件:
1、 继承的存在(继承是多态的基础,没有继承就没有多态).
2、 子类重写父类的方法(多态下调用子类重写的方法).
3、父类引用变量指向子类对象(子类到父类的类型转换).
重载（overload）和重写（override）是实现多态的两种主要方式。

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("看家");  
    }  
}