Java⾯向对象的三⼤特征以及理解
Java⾯向对象的三⼤特征为：封装、继承和多态，本⽂说说我对三⼤特性的理解。
1.封装
Java中的封装是指⼀个类把⾃⼰内部的实现细节进⾏隐藏，只暴露对外的接⼝（setter和getter⽅法）。封装⼜分为属性的封装和⽅法的封装。把属性定义为私有的，它们通过setter和getter⽅法来对属性的值进⾏设定和获取。下⾯我举⼀个简单的封装例⼦
public class Person {
private int id;
private String name;
private Person person;
public int getId() {
return id;
}
public String getName() {
return name;
}
public Person getPerson() {
return person;
}
public void setId(int id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
public void setPerson(Person person) {
this.person = person;
}
}
在Person类中，定义了三个成员变量，分别为id name person，它们的访问修饰都是private私有的，通过setter和getter⽅法对这些变量进⾏设值以及取值。那么这么做有什么好处呢？封装的意义就是增强类的信息隐藏与模块化，提⾼安全性。封装的主要作⽤也是对外部隐藏具体的实现细节，增加程序的安全性。
2.继承
Java中的继承是指在⼀个现有类（⽗类）的基础上在构建⼀个新类（⼦类），⼦类可以拥有⽗类的成
员变量以及成员⽅法（但是不⼀定能访问或调⽤，例如⽗类中private私有的成员变量以及⽅法不能访问和调⽤）。继承的作⽤就是能提⾼代码的复⽤性。⼦类拥有⽗类中的⼀切（拥有不⼀定能使⽤），它可以访问和使⽤⽗类中的⾮私有成员变量，以及重写⽗类中的⾮私有成员⽅法。
⽗类：
public class Person {
private int a=1;//⽗类私有成员变量
private int id;
private String name;
private int age;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [id=" + id + ", name=" + name + ", age=" + age + "]"; }
public void say() {
System.out.println("person say..");
}
public void run() {
System.out.println("");
}
//⽗类的私有⽅法
private void show() {
System.out.println("");
}
}
⼦类：
public class Student extends Person {
@Override
public void say() {
super.say();
}
@Override
public void run() {
super.run();
}
public static void main(String[] args) {
Student stu = new Student();
//stu.a=1;//⼦类对象对⽗类的私有成员变量使⽤报错！
//stu.show();//⼦类对象调⽤⽗类的私有⽅法，同样报错！
stu.say();
stu.run();
}
}
继承的好处是实现代码的复⽤以及扩展，⼦类通过对⽗类代码的复⽤，可以不⽤再定义⽗类中已经定义的成员变量，⽅法上直接对⽗类的⽅法进⾏重写实现了扩展。
多态
多态就是指多种状态，就是说当⼀个操作在不同的对象时，会产⽣不同的结果。
在Java中，实现多态的⽅式有两种，⼀种是编译时的多态，另外⼀种是运⾏时多态，编译时的多态是通过⽅法的重载实现的，⽽运⾏时多态是通过⽅法的重写实现的。
⽅法的重载是指在同⼀个类中，有多个⽅法名相同的⽅法，但是这些⽅法有着不同的参数列表，在编译期我们就可以确定到底调⽤哪个⽅法。
⽅法的重写，⼦类重写⽗类中的⽅法（包括接⼝的实现），⽗类的引⽤不仅可以指向⽗类的对象，⽽且还可以指向⼦类的对象。当⽗类的引⽤指向⼦类的引⽤时，只有在运⾏时才能确定调⽤哪个⽅法。
其实在运⾏时的多态的实现，需要满⾜三个条件：1.继承（包括接⼝的实现）2.⽅法的重写 3.⽗类的引⽤指向⼦类对象
并且，我们说的多态都是类中⽅法的多态，属性是没有多态性的。⽅法的重载我这⾥就不举例说明了，我说⼀下运⾏时的多态。
接⼝
package cn.csu.ksh;
public interface Animal {
void shout();
}
实现类
public class Dog implements Animal{
@Override
public void shout() {
System.out.println("");
}
}
实现类
package cn.csu.ksh;
public class Cat implements Animal {
@Override
public void shout() {
System.out.println("");
}
}
测试：
package cn.csu.ksh;
public class AnimalTest {
public static void main(String[] args) {
//⽗类的引⽤指向⼦类对象
Animal d = new Dog();java面向对象的特征有哪些方面
animalShout(d);
//⽗类的引⽤指向⼦类对象
Animal c= new Cat();
animalShout(c);
}
public static void animalShout(Animal animal) {  animal.shout();
}
}

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