[厉害了，我的JAVA基础]（一）面向对象的三大特征

封装

　　封装是面向对象的三大特征之一，它指的是将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，而是通过该类所提供的方法来实现对内部信息的操作和访问。
1. 对一个类或对象实现良好的封装，可以实现一下目的：
✈隐藏类的实现细节
✈让使用者只能通过事先预定的方法来访问数据，从而可以在该方法里加入控制逻辑，限制对成员变量的不合理访问
✈可进行数据检查，从而有利于保证对象信息的完整性
✈便于修改，提高代码的可维护性
2. 为了实现良好的封装，需要从两个方面考虑
✈将对象的成员变量和实现细节隐藏起来，不允许外部直接访问
✈把方法暴露出来，让方法来控制对这些成员变量进行安全的访问和操作
3. 访问控制符
访问控制级别图




访问控制级别表




例如：public class Person {
//使用private修饰成员变量，将这些成员变量隐藏起来
private String name;
private int age;

//提供方法来操作name成员变量
public void setName(String name) {
//执行合理性校验，要求用户名必须在2——6位之间
if(name.length() >6 || name.length() <2){
System.out.println("您设置的用户名不符合要求！");
return;
}else{
this.name = name;
}
}

public String getName() {
return name;
}

//提供方法来操作age成员变量
public void setAge(int age) {
//执行合理性检验，要求用户年龄在0——100之间
if(age > 100 || age <0){
System.out.println("您设置的年龄不合法！");
}else{
this.age = age;
}
}

public int getAge() {
return age;
}
}

继承

1.Java中只支持单继承
Java的继承通过extends关键字来实现，实现继承的类被称为子类，被继承的类称为父类，在JAVA中单继承的意思是，一个类只有一个直接父类，但是java支持多重继承，如下：
单继承：class A(){}
class B extends A (){} 多重继承：class A{}
class B extends A {}
class C extends B {} 2.子类拥有父类非private的属性、方法public class Bird {

public String name="鸟类";

public void fly(){
System.out.println("我能在天空自由的飞翔。。。。。");
}
}

public class Ostrich extends Bird {
}

public static void main(String[] args) {
Ostrich ostrich = new Ostrich();
ostrich.fly();
System.out.println(ostrich.name);
}

运行结果：我能在天空自由的飞翔。。。。。
鸟类3.子类可以重写父类方法
重写又叫覆盖，方法的重写要遵循“两同两小一大”规则，“两同”即方法名相同、形参列表相同；“两小”指的是子类方法返回值类型应比父类方法返回值类型更小或相等，子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等；“一大”指的是子类方法的访问权限应比父类方法的访问权限更大或相等。public class Ostrich extends Bird {
@Override
public void fly(){
System.out.println("鸵鸟只能在地上跑。。。。");
}
}运行结果：鸵鸟只能在地上跑。。。。
鸟类注意：如果父类的方法是private限定的，而子类定义了一个方法具有与父类方法相同的方法名、相同的形参列表、相同的返回值类型的方法，依然不是重写，只是定义的一个新方法。
4.super限定
如果需要在子类方法中调用父类被覆盖的实例方法，则可使用super限定来调用父类被覆盖的实例方法。如下代码所示：

public class Ostrich extends Bird {

@Override
public void fly(){
System.out.println("鸵鸟只能在地上跑。。。。");
}

public void callOverrideMethod(){
super.fly();
}
public void accessBase(){
System.out.println(super.name);
}

}

public static void main(String[] args) {
Ostrich ostrich = new Ostrich();
ostrich.callOverrideMethod();
ostrich.accessBase();
}

运行结果：我能在天空自由的飞翔。。。。。
鸟类5.调用父类构造器
子类不会获得父类的构造器，但子类构造器里可以调用父类构造器的初始化代码。在一个构造器中调用另一个重载的构造器使用this调用来完成，在子类构造器中调用父类构造器使用super调用来完成。
示例代码如下：public class Creature {
public Creature(){
System.out.println("Creature无参数的构造器。。。");
}
}

public class Animal extends Creature {
public Animal(String name){
System.out.println("Animal带一个参数的构造器，该动物的name为"+name);
}

public Animal(String name,int age){
//使用this调用同一个重载构造器
this(name);
System.out.println("Animal带两个参数的构造器，其age为"+age);
}
}

public class Wolf extends Animal{

public Wolf(){
//显示调用父类有两个参数的构造器
super("灰太狼",3);
System.out.println("Wolf的无参构造器");
}
}

public static void main(String[] args) {
new Wolf();
}

运行结果：Creature无参数的构造器。。。
Animal带一个参数的构造器，该动物的name为灰太狼
Animal带两个参数的构造器，其age为3
Wolf的无参构造器从上面运行过程来看，创建任何对象总是从该类所在继承树最顶层的构造器开始执行，然后依次向下执行，最后才执行到本类的构造器。如果某个父类通过this调用了同类中重载的构造器，就会依次执行此父类的多个构造器。

多态

简单说就是子父类（接口或实现）中的类型转换
1.属性的特点：属性不是多态的，当子类中出现相同属性时，以左边的引用为准public class A {
int num = 3;
}

public class B extends A {
int num = 5;
}

public static void main(String[] args) {
A a = new B();
System.out.println(a.num);  //输出3
        
B b = new B();
System.out.println(b.num);  //输出5
}

2.多态的定义
 允许不同类的对象对同意消息做出响应，即同一消息可以根据发送对象的不同而采用多种不同的行为方式（发送消息就是函数调用）
3.实现多态的技术称为：动态绑定，是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。
4.多态存在的必要条件：要有继承、要有重写、父类引用指向子类对象
更多关于多态的详细内容请参考如下链接：
https://www.cnblogs.com/zeze/p/6394231.html

http://blog.csdn.net/qq_31655965/article/details/54746235