JAVA面对象的三大特性

一、封装：
java中的对象设计中，可以对一个类里面的属性、方法、构造方法、一般方法通过改变访问权限修饰符，来进行封装。修饰符分为：1.public 2.default 3.protected 4.private。在进行封装的时候就可以将访问权限修饰符改为第4个（private）意思就是将修饰符为private的对象或者属性进行访问权限的限制，只在本类里访问，相当于用一个盒子包起来，外部访问不到，也看不到具体是什么。封装就是运用private修饰符来封装自己需要封装的属性或者方法等。
二、继承：
继承从字面意思出发就是，父亲把财产继承给儿子。java中页可以有继承这一关系。继承就是创建两个类，一个当做父类，而另一个当做子类（子类也可以有多个），继承也可以多重继承，比如一个父类有一个子类，而这个子类页可以再有一个子类。但是一个子类只能有一个父类。子类和父类的区分就在于：
//这是一个父类
public class Animal {
private String name;
private int id;
public Animal(String myName, int myid) {
name = myName;
id = myid;
}
public void eat(){
System.out.println(name+“正在吃”);
}
public void sleep(){
System.out.println(name+“正在睡”);
}
public void introduction() {
System.out.println(“大家好！我是” + id + “号” + name + “.”);
}
}
//这是一个子类
public class Penguin extends Animal {
public Penguin(String myName, int myid) {
super(myName, myid);
}
}
//这是另一个子类
public class Mouse extends Animal {
public Mouse(String myName, int myid) {
super(myName, myid);
}
}
继承关键字可以使用 extends（在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。） 和 implements（使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。） 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object
继承的特性
1.子类拥有父类非 private 的属性、方法。

2.子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

3.子类可以用自己的方式实现父类的方法。

4.Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 A 类继承 B 类，B 类继承 C 类，所以按照关系就是 C 类是 B 类的父类，B 类是 A 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。

5.提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

6.子类不可以继承父类的构造器（构造方法）

7.子类和父类必须是要有一点的联系，比如（人是一个父类，而他的子类必须是男人、女人、小孩等。而不是像飞机、电脑、手机等。与人类无关的类）
三、多态：
多态就是同一个接口，使用不同的实例而执行不同操作（电脑的USB接口就可以有不同的操作，比如USB是一个借口，从这个接口、我们可以连接：鼠标、键盘、u盘、手机等。这些例子在接入USB接口是就可以有不同的操作）
多态的优点：

1. 消除类型之间的耦合关系
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化性

多态存在的三个必要条件：
1.继承
2.重写
3.父类引用指向子类对象
对象的多态性：父子类对象的转换

向上转型：子类对象变为父类对象，语法： 父类 父类对象 = 子类实例， 自动；

向下转型：父类对象变为子类对象，语法： 子类 子类对象 = （子类）父类实例，强制。
演示代码（对象向上转型）：

class A{

publicvoid print(){

System.out.println(“A,public void print(){}”);

}

class B extends A{ //继承A类

publicvoid print(){ //方法覆写

System.out.println(“B,public void print(){}”);

publicclass TestDemo{

publicstaticvoid main(String args[]){

A a = new B(); //向上转型

a.print(); //调用被覆写过的方法

执行结果：

B,public void print(){}

本程序实现了一个对象的向上转型操作，虽然最后调用print（）方法的是A类对象，但是由于此时实例化的是子类对象“new B（）；”，而且print（）方法被子类覆写了，所以最终调用的就是被B类覆写过的print（）方法。

演示代码（对象向下转型）：

public void print(){

class B extends A{//继承A类

public void print(){//方法覆写

public class TestDemo{

public static void main(String args[]){

A a = new B();//向上转型

B b = (B)a;//向下转型

b.print();//调用被覆写过的方法

本程序强制将父类对象变为了子类实例，由于本程序在开始实例化的依然是子类对象（new B（）；），所以最终调用的print（）方法依然是被子类覆写过的方法。

演示代码（观察错误代码）：

A a = new A();//没有转型

B b = (B)a;//向下转型错误：java.lang.ClassCastException: A cannot be cast to B

b.print();

Exception in thread “main” java.lang.ClassCastException: A cannot be cast to B

at TestDemo.main(TestDemo.java:14)

以上的程序在编译时没有发生任何的错误信息，但是在执行时出现了“ClassCastException”错误提示，表示的是类转换异常，即两个没有关系的类互相发生了对象的强制转换，所以可以得出结论：当对象发生向下转型关系前，一定要首先发生对象的向上转型关系。

结论：

1.定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。

2.父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，它是无可奈何的；

3.父类中的一个方法只有在在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用；

4.对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接。

演示代码（多态的使用）：

class Father{

publicvoid wait1(){

wait2();

//这是父类中的wait2()方法，因为下面的子类中重写了该方法

//所以在父类类型的引用中调用时，这个方法将不再有效

//取而代之的是将调用子类中重写的wait2()方法

publicvoid wait2(){

System.out.println(“Father wait2”);

class Child extends Father{

//wait1(String name)是对wait1()方法的一个重载

//由于在父类中没有定义这个方法，所以它不能被父类类型的引用调用

//所以在下面的main方法中child.wait1(“沐兮沐楚”)是不对的

publicvoid wait1(String name){

System.out.println(“Child name:” + name);

//func2()重写了父类Father中的func2()方法

//如果父类类型的引用中调用了func2()方法，那么必然是子类中重写的这个方法

System.out.println(“Child wait2”);

publicstaticvoid main(String[] args) {

Father child = new Child();

//child.wait1(“沐兮沐楚”); //错误

child.wait2();

Child wait2

上面的程序是个很典型的多态的例子。子类Child继承了父类Father，并重载了父类的wait1()方法，重写了父类的wait2()方法。重载后的wait1(String name)和wait1()不再是同一个方法，由于父类中没有wait1(String name)，那么，父类类型的引用child就不能调用wait1(String name)方法。而子类重写了wait2()方法，那么父类类型的引用child在调用该方法时将会调用子类中重写的wait2()。

对于多态，可以总结它为：

一、使用父类类型的引用指向子类的对象；

二、该引用只能调用父类中定义的方法和变量；

三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）

四、变量不能被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在编译时会报错。