共计 5533 个字符，预计需要花费 14 分钟才能阅读完成。
一，前言
明天总结一下对于 Java 的三大个性，封装，继承，多态。其实对于三大个性对于从事编程人员来说都是根本的了，毕竟只有接触 Java 这些都是先要意识的，接下来就零碎总结一下。
二，封装
先来说说个性之一：封装
2.1，什么是封装
封装（Encapsulation）是面向对象办法的重要准则，就是把对象的属性和操作（或服务）联合为一个独立的整体，并尽可能暗藏对象的外部实现细节。
将类的某些信息暗藏在类的外部，不容许内部程序进行间接的拜访调用。
通过该类提供的办法来实现对暗藏信息的操作和拜访。
暗藏对象的信息。
留出拜访的对外接口。
举个比拟艰深的例子，比方咱们的 USB 接口。如果咱们须要外设且只须要将设施接入 USB 接口中，而外部是如何工作的，对于使用者来说并不重要。而 USB 接口就是对外提供的拜访接口。
说了这么多，那为什么应用封装？
2.2，封装的特点
对成员变量履行更精确的管制。
封装能够暗藏外部程序实现的细节。
良好的封装可能缩小代码之间的耦合度。
内部成员无奈批改已封装好的程序代码。
不便数据查看，有利于爱护对象信息的完整性，同时也进步程序的安全性。
便于批改，体高代码的可维护性。
2.3，封装的应用
应用 private 修饰符，示意最小的拜访权限。
对成员变量的拜访，对立提供 setXXX，getXXX 办法。
上面请看一个 Student 实体对象类：
public class Student implements Serializable {
private Long id;
private String name;
private Integer sex;
public Long getId() {return id;}
public void setId(Long id) {this.id = id;}
public String getName() {return name;}
public void setName(String name) {this.name = name;}
public Integer getSex() {return sex;}
public void setSex(Integer sex) {this.sex = sex;}}
剖析：对于下面的一个实体对象，我想大家都曾经很相熟了。将对象中的成员变量进行私有化，内部程序是无法访问的。然而咱们对外提供了拜访的形式，就是 set 和 get 办法。
而对于这样一个实体对象，内部程序只有赋值和获取值的权限，是无奈对外部进行批改，因而咱们还能够在外部进行一些逻辑上的判断等，来实现咱们业务上的须要。
到这里应该就明确封装对于咱们的程序是如许重要。上面再来说说继承的那点事。
三，继承
3.1，什么是继承
继承就是子类继承父类的特色和行为，使得子类对象（实例）具备父类的实例域和办法，或子类从父类继承办法，使得子类具备父类雷同的行为。当然，如果在父类中领有公有属性(private 润饰)，则子类是不能被继承的。
3.2，继承的特点
1，对于继承的注意事项：
只反对单继承，即一个子类只容许有一个父类，然而能够实现多级继承，及子类领有惟一的父类，而父类还能够再继承。
子类能够领有父类的属性和办法。
子类能够领有本人的属性和办法。
子类能够重写笼罩父类的办法。
2，继承的特点：
进步代码复用性。
父类的属性办法能够用于子类。
能够轻松的定义子类。
使设计应用程序变得简略。
3.3，继承的应用
1，在父子类关系继承中，如果成员变量重名，则创立子类对象时，拜访有两种形式。
a，间接通过子类对象拜访成员变量
等号右边是谁，就优先应用谁，如果没有就向上找。
b，间接通过成员办法拜访成员变量
该办法属于谁，谁就优先应用，如果没有就向上找。
public class FU {
int numFU = 10;
int num = 100;
public void method(){System.out.println("父类成员变量："+numFU);
}
public void methodFU(){System.out.println("父类成员办法!");
}}
public class Zi extends FU{
int numZi = 20;
int num = 200;
public void method(){System.out.println("子类成员变量："+numFU);
}
public void methodZi(){System.out.println("子类办法！");
}}
public class ExtendDemo {
public static void main(String[] args) {FU fu = new FU();
// 父类的实体对象只能调用父类的成员变量
System.out.println("父类：" + fu.numFU); // 后果：10
Zi zi = new Zi();
System.out.println("调用父类：" + zi.numFU); // 后果：10
System.out.println("子类：" + zi.numZi); // 后果：20
/** 输入后果为 200，证实在重名状况下，如果子类中存在则优先应用，* 如果不存在则去父类查找，但如果父类也没有那么编译期就会报错。*/
System.out.println(zi.num); // 后果：200
/**
* 通过成员办法调用成员变量
*/
zi.method(); // 后果：10}}
2，同理：
成员办法也是一样的，创立的对象是谁，就优先应用谁，如果没有则间接向上找。
注意事项：
无论是成员变量还是成员办法，如果没有都是向上父类中查找，相对不会向下查找子类的。
3，在继承关系中，对于成员变量的应用：
部分成员变量：间接应用
本类成员变量：this. 成员变量
父类成员变量：super. 父类成员变量
int numZi = 10;
public void method() {
int numMethod = 20;
System.out.println(numMethod); // 拜访局部变量
System.out.println(this.numZi); // 拜访本类成员变量
System.out.println(super.numFu); // 拜访本类成员变量
}
3.4，重写，重载
重写(override)
是子类对父类的容许拜访的办法的实现过程进行从新编写, 返回值和形参都不能扭转。即外壳不变，外围重写！
class Animal{
public void move(){
System.out.println("动物行走！");}
}
class Dog extends Animal{
public void move(){
System.out.println("狗能够跑和走");}
}
public class TestDog{
public static void main(String args[]){
Animal a = new Animal(); // Animal 对象
Animal b = new Dog(); // Dog 对象
a.move();// 执行 Animal 类的办法
b.move();// 执行 Dog 类的办法}
}
重写的规定：
1，参数列表必须与被重写办法雷同。
2，拜访权限不能比父类中被重写的办法的拜访权限更低（public>protected>(default)>private）。
3，父类成员的办法只能被它的子类重写。
4，被 final 润饰的办法不能被重写。
5，构造方法不能
重载(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，被重载的办法能够扭转拜访修饰符。
3.5，this，super 关键字
super() 关键字的用法
1，子类的成员办法中，拜访父类的成员变量。
2，子类的成员办法中，拜访父类的成员办法。
3，子类的构造方法中，拜访父类的构造方法。
this 关键字用法：
1，本类成员办法中，拜访本类的成员变量。
2，本类成员办法中，拜访本类的另一个成员办法。
3，本类的构造方法中，拜访本类的另一个构造方法。
留神：
this 关键字同 super 一样，必须在构造方法的第一个语句，且是惟一的。
this 与 super 不能同时存在。
3.6，结构器
继承关系中，父子类构造方法的拜访特点：
1，在子类构造方法中有一个默认隐含的 super(); 调用，因而肯定是先调用父类构造方法，再调用子类构造方法。
2，子类结构能够通过 super(); 调用父类的重载结构。(重载)
3，super(); 的父类调用构造方法，必须在子类结构中的第一行，就是第一个; 号完结的元素，并且只能调用一次。
3.7，对于继承的注意事项：
1，Java 语言是单继承的，一个子类只能有惟一一个父类
2，Java 语言能够是多级继承，一个子类有一个父类，一个父类还能够有一个父类。
3，一个子类只有一个父类，然而一个父类能够有多个子类。
四，多态
4.1，什么是多态
多态是同一个行为具备多个不同表现形式或状态的能力。
4.2，多态的特点
1，打消类型之间的耦合关系，实现低耦合。
2，灵活性。
3，可扩充性。
4，可替换性。
4.3，多态的体现模式
继承
父类援用指向子类
重写
留神：在多态中，编译看右边，运行看左边
public class MultiDemo {
public static void main(String[] args) {
// 多态的援用，就是向上转型
Animals dog = new Dog();
dog.eat();
Animals cat = new Cat();
cat.eat();
// 如果要调用父类中没有的办法，则要向下转型
Dog dogDown = (Dog)dog;
dogDown.watchDoor();}}
class Animals {
public void eat(){System.out.println("动物吃饭！");
}}
class Dog extends Animals{
public void eat(){System.out.println("狗在吃骨头！");
}
public void watchDoor(){System.out.println("狗看门！");
}}
class Cat extends Animals{
public void eat(){System.out.println("猫在吃鱼！");
}}
4.4，向上转型
1，格局：父类名称 对象名 = new 子类名称();
含意：右侧创立一个子类对象，把它当作父类来应用。留神：向上转型肯定是平安的。毛病：一旦向上转型，子类中本来特有的办法就不能再被调用了。五，接口
最初，对于接口方面的细节，不同版本之间的区别。
问题形容：
当初接口中须要抽取一个私有的办法，用来解决默认办法中代码反复的问题。
然而这个共有的办法不能让实现类实现，所以应该设置为私有化。
在 JDK8 之后：
1，default 润饰，接口里容许定义默认的办法，但默认办法也能够笼罩重写。
2，接口里容许定义静态方法。
在 JDK9 之后：
1，一般公有办法，解决多个默认办法之间代码反复的问题。
2，动态私有化，解决多个静态方法之间代码反复问题。
接口的注意事项：
1，不能通过接口的实现类对象去调用接口中的静态方法。
正确语法：接口名称调用静态方法。
接口当中的常量的应用：
1，接口当中定义的常量：能够省略 public static final。
2，接口当中定义的常量：必须进行赋值。
3，接口当中定义的常量：常量的名称要全副大写，多个名称之间应用下划线进行宰割。
应用接口的注意事项：
1，接口是没有动态代码块或者构造方法
2，一个类的间接父类是惟一的，然而一个类能够同时实现多个接口。
3，如果实现类没有笼罩重写接口中所有的形象办法，那么实现类就必须是一个抽象类
4，如果实现类中实现多个接口，存在反复的形象办法，那么只须要笼罩重写一次即可。
5，在 Java 中，如果实现类的间接继承父类与实现接口发生冲突时，父类优先级高于接口。
接口之间的关系：
1，多个接口之间是继承关系。
2，多个父接口当中默认办法如果反复，那么子接口必须进行默认办法的笼罩重写。
六，总结
对于 Java 的个性根本总结结束，当然还有一些细节没有欠缺。其实对于这些 Java 根底肯定要把握并熟记，因为这与咱们的理论开发密切相关，好的编码习惯能力铸就好的产品，能力被社会认可。
