java面向对象总结_Java面向对象知识点总结大全详解

一. 封装：

封装是把对象的属性和操作结合为一个独立的整体，隐藏对象内部操作的实现，用户只需要通过其对外提供的方法来访问该对象，无需知道其内部实现细节。

优点：

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) 方法，所以输出如上。

转载请注明来源网站:www.itxm.cn谢谢！

分享到：