一. 封装：
封装是把对象的属性和操作结合为一个独立的整体，隐藏对象内部操作的实现，用户只需要通过其对外提供的方法来访问该对象，无需知道其内部实现细节。
优点：
1.隐藏内部实现细节，提供公共访问方式
2.类内部可以自由修改不影响其调用者
3.减少耦合度，提高安全性
二. 继承：
继承是一个对象获取另一个对象属性的过程，关键字为 extends 和 implements 。
1). IS-A关系(一个对象所属于另一个对象)：
方式一. 用extends来实现继承：
public class Animal {
public void eat() {
System.out.println(“Animal eating…”);
}
}
public class Mammal extends Animal {
public void eat() {
System.out.println(“Mammal eating…”);
}
}
public class Dog extends Mammal {
public void eat() {
System.out.println(“Dog eating…”);
}
}
方式二. 用implements来实现继承：
public interface Animal {
void eat();
}
public class Mammal extends Animal {
public void eat() {
System.out.println(“Mammal eating…”);
}
}
public class Dog extends Mammal {
public void eat() {
System.out.println(“Dog eating…”);
}
}
无论方式一还是方式二，我们都可以用instanceof关键字检查得出：Mammal是一个Animal(哺乳动物也是动物)；Dog既是一个Mammal，也是一个Animal(狗既是哺乳动物也是动物)。
public class Test {
public static void main(String[] args) {
Mammal m = new Mammal();
Dog d = new Dog();
System.out.print(m instanceof Animal);
System.out.print(d instanceof Mammal);
System.out.print(d instanceof Animal);
}
}
输出结果：
true true true
2). HAS-A关系(一个对象含有另一个对象的一些属性)：
public class Car{}
public class Speed{}
public class Benz extends Car{
private Speed sp;
}
Benz含有Spend属性，但Benz不是Spend
三. 多态：
实现多态的三个必要条件：继承、重写、父类引用指向子类对象。
1). 向上转型：
我们实例化一个Dog对象可以用 Dog d = new Dog(); 我们也可以用 Animal d = new Dog(); ，后者就是向上转型(父引用指向子对象)，上面两种方式创建出来的对象d，调用 d.eat(); 输出的结果都是 Dog eating… ，这就体现出了java得多态。向上转型创建的对象会遗失掉和父类不同的方法和变量(不能用来调用子类特有的方法和变量)。
2). 举例说明：
class A {
public String show(D obj) {
return (“A and D”);
}
public String show(A obj) {
return (“A and A”);
}
}
class B extends A {
public String show(B obj) {
return (“B and B”);
}
public String show(A obj) {
return (“B and A”);
}
}
class C extends B {}
class D extends B {}
class Test {
public static void main(String[] args) {
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();
System.out.println(a1.show(b)); //
System.out.println(a1.show(c)); //
System.out.println(a1.show(d)); //
System.out.println(a2.show(b)); //
System.out.println(a2.show(c)); //
System.out.println(a2.show(d)); //
System.out.println(b.show(b)); //
System.out.println(b.show(c)); //
System.out.println(b.show(d)); //
}
}
输出结果：
A and A //
A and A //
A and D //
B and A //
B and A //
A and D //
B and B //
B and B //
A and D //
前三个比较简单不容易出错，看看下面几个：
1：a2是A的引用指向B对象，向上转型创建的对象会遗失掉和父类不同的方法和变量，所以a2只能调用 show(D obj) 、 show(A obj) 两个方法，所以 a2.show(b) 应该调用 show(A obj) 方法，B中重写了该方法，所以运行时JVM会调用B类中重写的 show(A obj) 方法，所以输出 B and A ；
2: 原理同；
3： a2.show(d) 应该调用 show(D obj) 方法，B中没有重写该方法所以调用的为A类中的该方法，所以输出为 A and D ;
4：b为B类对象，可调用A类中 show(D obj) 、B类中 show(B obj) 、B类中 show(A obj) 方法，所以输出如上。
转载请注明来源网站:blog.ytso.com谢谢！
原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/14637.html