Java封装、继承、多态三大特征的理解_Java

首先先简单的说一下其3大特性的定义：

封装：隐藏对象的属性和实现细节，仅对外公开接口,控制在程序中属性的读和修改的访问级别。将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，一特定的访问权限来使用类的成员。封装的基本要求是: 把所有的属性私有化，对每个属性提供getter和setter方法，如果有一个带参的构造函数的话，那一定要写一个不带参的构造函数。在开发的时候经常要对已经编写的类进行测试，所以在有的时候还有重写tostring方法，但这不是必须的。

继承：通过继承实现代码复用。java中所有的类都是通过直接或间接地继承java.lang.object类得到的。继承而得到的类称为子类，被继承的类称为父类。子类不能继承父类中访问权限为private的成员变量和方法。子类可以重写父类的方法，及命名与父类同名的成员变量。但java不支持多重继承，即一个类从多个超类派生的能力。在开发中尽量减少继承关系，这样做是为了把程序的耦合度降低。

多态：多态又分为设计时多态和运行时多态，例如重载又被称为设计时多态，而对于覆盖或继承的方法，java运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态。总而言之，面向对象的设计的典型特点就是继承，封装和多态，这些特点也是面向对象之所以能如此盛行的关键所在。

封装

java中类的属性的访问权限默认值不是private,要想隐藏该属性的方法，就可以加private修饰符，来限制只能够在类的内部进行访问。

对于类中的私有属性，要对其给出一对方法（getxxx，setxxx()）访问私有属性，保证对私有属性的操作和安全性。

方法的封装，该公开的公开，该隐藏的隐藏。

java的继承

继承，是对有着共同特性的多类事物，进行再抽象成一个类。

java中的继承要使用extends关键字，并且java中指允许单继承，也就是一个类只能有一个父类。

构造方法不能被继承。

java方法中的覆盖

子类中有和父类中可访问的同名同返回同参数列表的方法时，就会覆盖从父类继承来的方法。

super()关键字

super(),表示在子类的构造方法调用父类的构造方法时，super()也只能在构造方法中的第一句。

java中的多态

有两种多态的机制：编译时多态、运行时多态

1、方法的重载：重载是指同一类中有多个同名的方法，但这些方法有着不同的参数。，因此在编译时就可以确定到底调用哪个方法，它是一种编译时多态。

2、方法的覆盖：子类可以覆盖父类的方法，因此同样的方法会在父类中与子类中有着不同的表现形式。在java语言中，基类的引用变量不仅可以指向基类的实例对象，也可以指向子类的实例对象，同样，接口中的引用变量也可以指向其实现类的实例对象。

public class a {
public string show(d obj) {
return ("a and d");
}
public string show(a obj) {
return ("a and a");
} 
}
public class b extends a{
public string show(b obj){
return ("b and b");
}
public string show(a obj){
return ("b and a");
} 
}
public class c extends b{
}
public class d extends b{
}
public 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("1--" + a1.show(b));
system.out.println("2--" + a1.show(c));
system.out.println("3--" + a1.show(d));
system.out.println("4--" + a2.show(b));
system.out.println("5--" + a2.show(c));
system.out.println("6--" + a2.show(d));
system.out.println("7--" + b.show(b));
system.out.println("8--" + b.show(c));
system.out.println("9--" + b.show(d)); 
}
}
1--a and a
2--a and a
3--a and d
4--b and a
5--b and a
6--a and d
7--b and b
8--b and b
9--a and d

当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。

这我们用一个例子来说明这句话所代表的含义：a2.show(b)；

这里a2是引用变量，为a类型，它引用的是b对象，因此按照上面那句话的意思是说有b来决定调用谁的方法,所以a2.show(b)应该要调用b中的show(b obj)，产生的结果应该是“b and b”，但是为什么会与前面的运行结果产生差异呢？这里我们忽略了后面那句话“但是这儿被调用的方法必须是在超类中定义过的”，那么show(b obj)在a类中存在吗？根本就不存在！所以这句话在这里不适用？那么难道是这句话错误了？非也！其实这句话还隐含这这句话：它仍然要按照继承链中调用方法的优先级来确认。所以它才会在a类中找到show(a obj)，同时由于b重写了该方法所以才会调用b类中的方法，否则就会调用a类中的方法。

以上所述是小编给大家介绍的java封装、继承、多态三大特征的理解，希望对大家有所帮助