Java⾯向对象编程之三⼤特性
Java⾯向对象编程作为⼀种编程思想，有三⼤特性，封装，继承，多态。对于⼀个类⽽⾔， 如何封装 呢？继承是⽗类和⼦类的关系， 继承关系如何实现的呢？⽗类和⼦类继承时的⽅法体是怎么样的关系呢？多态是多个类之间的关系，类有不同的⾏为和属性，其他类也有这样的⽅法和属性，就实现了多态的关系，不同类的多态实现是怎么样实现的呢？
⼀：⾯向对象编程三⼤特性
⾯向对象编程是利⽤ 类和对象编程的⼀种思想。万物可归类，类是对于世界事物的⾼度抽象 ，不同的事物之间有不同的关系 ，⼀个类⾃⾝与外界的封装关系，⼀个⽗类和⼦类的继承关系， ⼀个类和多个类的多态关系。万物皆对象，对象是具体的世界事物，⾯向对象的三⼤特征封装，继承，多态，封装，封装说明⼀个类⾏为和属性与其他类的关系，低耦合，⾼内聚；继承是⽗类和⼦类的关系，多态说的是类与类的关系。
1. 封装
什么是封装
把客观事物封装成抽象的类，并且把⾃⼰的数据和⽅法只让可信的类或者对象操作，对不可信的进⾏信息隐藏。也 就 是 说抽象数据类型对数据信息以及对数据的操作进⾏打包，将其变成⼀个不可分割 的实体，在这个实体内部，我们对数据进⾏隐藏和保密，只留下⼀些接⼝供外部调⽤。java面向对象的特征有哪些方面
简单的说，⼀个类就是⼀个封装了数据以及操作这些数据的代码的逻辑实体。在⼀个对象内部，某些代码或某些数据可以是私有的，不能被外界访问。通过这种⽅式，对象对内部数据提供了不同级别的保护，以防⽌程序中⽆关的部分意外的改变或错误的使⽤了对象的私有部分。
封装隐藏了类的内部实现机制，可以在不影响使⽤的情况下改变类的内部结构，同时也保护了数据。对外界⽽已它的内部细节是隐藏的，暴露给外界的只是它的访问⽅法。
就好⽐⼀个烤⾯包机，我们把⾯包（数据）放进去，按下开关，过了⼀会，它就会⾃动弹出烤好的⾯包（处理后的信息），⽽这个过程是怎么烤的（对数据的操作），我们是不需要知道的，
为什么需要封装
隐藏⼀个类中不需要对外提供的实现细节；
属性的封装：使⽤者只能通过事先定制好的⽅法来访问数据，可以⽅便地加⼊逻辑控制，限制对属性的 不合理操作；
⽅法的封装：使⽤者按照既定的⽅式调⽤⽅法，不必关⼼⽅法的内部实现，便于使⽤； 便于修改，增强 代码的可维护性；
-如何封装
利⽤权限修饰符来描述⽅法体或属性。private修饰的属性或⽅法为该类所特有，在任何其他类中都不能直接访问；default修饰的属性或⽅法具有包访问特性，同⼀个包中的其他类可以访问；protected修饰的属性或⽅法在同⼀个中的其他类可以访问，同时对于不在同⼀个包中的⼦类中也可以访问；public修饰的属性或⽅法外部类中都可以直接访问。
封装类似于⿊箱操作，其设计要求是低耦合，⾼内聚。⼀个具体复杂的对象有很多的属性和⽅法，有些需要公开，有些不需要公开，就好⽐⼀个具体的⼈的信息，有些是public，有些是private，⽽有些是protecred，别⼈问到的时候对于怎么样的信息都有不同的态度。根据与这个⼈的关系来回答问题，封装的结果是输出结果，不问过程，其中，public是可以被任何变量访问的，private是该类私有的，protected类是受保护的，可以被该类所述的包内的所有的其他类访问，其⼦类也可以访问。
⽐如我们将⼀个房⼦看做是⼀个对象，⾥⾯的漂亮的装饰，如沙发、电视剧、空调、茶桌等等都是该房⼦的私有属性，但是如果我们没有那些墙遮挡，是不是别⼈就会⼀览⽆余呢？没有⼀点⼉隐私！就是存在那个遮挡的墙，我们既能够有⾃⼰的隐私⽽且我们可以随意的更改⾥⾯的摆设⽽不会影响到其他的。但是如果没有门窗，⼀个包裹的严严实实的⿊盒⼦，⼜有什么存在的意义呢？所以通过门窗别⼈也能够看到⾥⾯的风景。所以说门窗就是房⼦对象留给外界访问的接⼝。
2.继承
- 什么是继承
继承是从已有的类中派⽣出新的类，新的类能吸收已有类的数据属性和⾏为，并能扩展新的能⼒。
在本职上是特殊——⼀般的关系，即常说的is-a关系。⼦类继承⽗类，表明⼦类是⼀种特殊的⽗类，并
且具有⽗类所不具有的⼀些属性或⽅法。从多种实现类中抽象出⼀个基类，使其具备多种实现类的共同特性 ，当实现类⽤extends关键字继承了基类（⽗类）后，实现类就具备了这些相同的属性。
继承的类叫做⼦类（派⽣类或者超类），被继承的类叫做⽗类（或者基类）。
⽐如从猫类、狗类、虎类中可以抽象出⼀个动物类，具有和猫、狗、虎类的共同特性（吃、跑、叫等）。
如何实现继承： Java通过extends关键字来实现继承，⽗类中通过private定义的变量和⽅法不会被继承，不能在⼦类中直接操作⽗类
如何实现继承： Java通过extends关键字来实现继承，⽗类中通过private定义的变量和⽅法不会被继承，不能在⼦类中直接操作⽗类通过private定义的变量以及⽅法。
继承的优点： 继承避免了对⼀般类和特殊类之间共同特征进⾏的重复描述，通过继承可以清晰地表达每⼀项共同特征所适应的概念范围——在⼀般类中定义的属性和操作适应于这个类本⾝以及它以下的每⼀层特殊类的全部对象。运⽤继承原则使得系统模型⽐较简练也⽐较清晰。
- 继承有哪些原则
成员变量的继承原则 具体的原则如下：
[u ] 能够继承⽗类的public和protected成员变量；不能够继承⽗类的private成员变量；
[u ] 对于⽗类的包访问权限成员变量，如果⼦类和⽗类在同⼀个包下，则⼦类能够继承；否则，⼦类不能够继承；
[y ] 对于⼦类可以继承的⽗类成员变量，如果在⼦类中出现了同名称的成员变量，则会发⽣隐藏现象，即⼦类的成员变量会屏蔽掉⽗类的同名成员变量。如果要在⼦类中访问⽗类中同名成员变量，需要使⽤super关键字来进⾏引⽤。
1.⽅法的重写
　⼦类如果对继承的⽗类的⽅法不满意（不适合），可以⾃⼰编写继承的⽅法，这种⽅式就称为⽅法的重写.通过重写⽗类的⽅法，可以⽤⾃⾝的⾏为代替⽗类的⾏为。当调⽤⽅法时会优先调⽤⼦类的⽅法。重写要注意：  a、返回值类型  b、⽅法名  c、参数类型及个数
　都要与⽗类继承的⽅法相同，才叫⽅法的重写。
　重载和重写的区别：
  ⽅法重载：在同⼀个类中处理不同数据的多个相同⽅法名的多态⼿段。
  ⽅法重写：相对继承⽽⾔，⼦类中对⽗类已经存在的⽅法进⾏区别化的修改
2. 继承初始化顺序
⽗类的构造器调⽤以及初始化过程⼀定在⼦类的前⾯
  1、初始化⽗类再初始化⼦类
  2、先执⾏初始化对象中属性，再执⾏构造⽅法中的初始化。
　基于上⾯两点，我们就知道实例化⼀个⼦类，java程序的执⾏顺序是：
　⽗类对象属性初始化---->⽗类对象构造⽅法---->⼦类对象属性初始化—>⼦类对象构造⽅法  　
　下⾯有个形象的图：
继承实例：
/**
1. 我是⽗类super
2. 我是⼦类sub
3. 先打印的是⽗类⾥⾯的在打印的⼦类⾥⾯
4. 从这个可以看出是先调⽤⽗类的构造⽅法创建⽗类对象再来调⽤⼦类⾥⾯的构造⽅法
*/
class Super{
public Super(){
System.out.println("我是⽗类super");
}
}
class Sub extends Super{
public Sub(){
System.out.println("我是⼦类sub");
}
}
public class InstanceDemo {
public static void main(String[] args) {
new Sub();
}
}
运⾏结果：
3.多态
相⽐于封装和继承，Java多态是三⼤特性中⽐较难的⼀个，封装和继承最后归结于多态， 多态指的是类和类的关系，两个类由继承关系，存在有⽅法的重写，故⽽可以在调⽤时有⽗类引⽤指向⼦类对象。⾃⼰对于多态的理解还不够深刻，故⽽转载了⼀篇关于多态⽐较好的⽂章。
public class main {
/**
* @param args
*/
public static void main(String[] args) {
//分别将animal实例化成三种动物，
Animal an = new Dog();
<();//根据每种动物⾃⾝的⽅法，⾃动选择内容
an = new Cat();
<();
an = new UnknowAnimal();
<();
}
}
//基本类，包含⼀个基本⽅法
class Animal{
public void cry(){
System.out.println("我不知道⾃⼰是什么动物。");
}
}
//声明⼦类，继承基本类，但有⾃⼰的⽅法
//实例化后优先使⽤⾃⾝的⽅法。
class Dog extends Animal{
public void cry(){
System.out.println("这是⼀条狗。");
}
}
class Cat extends Animal{
public void cry(){
System.out.println("这是⼀只猫。");
}
}
//这个⼦类⾃⾝没定义⽅法，实例化后会使⽤从⽗类继承来的⽅法class UnknowAnimal extends Animal{
}
运⾏结果如下：

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。