一，前言
明天总结一下对于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根底肯定要把握并熟记，因为这与咱们的理论开发密切相关，好的编码习惯能力铸就好的产品，能力被社会认可。