前言
面向对象三大基本特性：封装，继承，多态，了解更详细的概念可以看这位博主的文章三大特性五大基本原则
提示：以下是本篇文章正文内容，下面案例可供参考
一、封装字段
1.概念：
封装字段是重构代码的一种操作，是通过一对存取方法来访问字段。存取方法也称为读/写方法或 getter 和 setter 方法。通常，在封装字段时，会将字段的访问修饰符更改为 private，这样就无法从类外部直接引用该字段。如果其他类要引用该字段，则它们必须使用存取方法。
可读属性get(); 可写属性set()
2.作用：
(1) 利用“封装字段”重构操作，可以从现有字段快速创建属性，然后使用对新属性的引用无缝更新代码。
(2) 当字段为 public 时，其他对象可以直接访问该字段并对其进行修改，而不会被拥有该字段的对象检测到。通过使用属性封装该字段，可以禁止对字段的直接访问。
(3) 为了创建新属性，“封装字段”操作将为要封装为 private 的字段更改访问修饰符，然后为该字段生成 get 和 set 访问器。
3.代码快速生成方法：
右键source----->generate Getters and Setters
4.代码举例：
虽然快速生成比较方便，如果初学者想要更好的了解此方法，建议先自己尝试写几遍。下面举个例子来说明如何字段封装：
public class E01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Teacher t = new Teacher(1001);//调用构造函数
int y = t.getTid();
System.out.println(y);
t.setTname("张三");
t.teach();
t.setTage(18);
t.teach();
int a = t.getTage();
System.out.println(a);
}
}
//写实体类
class Teacher {
/*有些东西不可以修改，所以写代码要注意把属性字段写成私有的，
通过方法开放*/
//属性（字段） 编号，姓名，年龄 ，课程 |
private int tid;//假设可读不可写
private String tname;// 可写不可读
private int age;//可读可写
//私有方法没办法赋值，所以要构造函数，一般写一个无参和有参的，否则会出错
public Teacher() {
}
public Teacher(int tid) {
this.tid=tid;
}
//1.可读不可写
public int getTid() {
return this.tid;
}
//2.可写不可读
public void setTname(String tname)// 可写
{
this.tname = tname;
}
//3.可写可读
public void setTage(int age) {
this.age = age;
}
public int getTage() {
return this.age;
}
// 行为 授课
public void teach() {
System.out.println(this.tname + "教师需要授课！");
}
}
简单画个图方便大家理解
二、继承
1.概念：继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。比如动物类（父类），狗类（子类）。
2.作用：
提高复用性，减少代码量， is的关系
3.特点：
（1）继承的关键字是extends。
（2）Java只支持单继承，不支持多继承，但支持多重继承。
（3）继承父类的所有成员属性（私有的也继承），但是构造函数没有被继承。
4.举例代码：
public class E02 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Animal dog= new Dog();//向上转型
dog.speak();
}
}
//父类
class Animal{
public String type;//
public void speak() {
System.out.println("不知道啥语言");
}
}
//子类
class Dog extends Animal{//JAVA只支持单继承，但支持多重继承。
//子类继承父类的成员，我们还要去改造继承过来的成员（主要指成员方法）
//改造父类继承过来的成员方法 ，用方法的重写。
//快速生成代码，输入sp,然后alt+/
@Override
public void speak() {
// TODO Auto-generated method stub
System.out.println("小狗都是汪汪地叫");
}
}
5.推荐文章：大家想深刻的了解继承，可以看看这一篇文章，写的真不错，有图可以方便大家更好的理解继承概念。
三、多态
1.概念：多态是同一个行为具有多个不同表现形式或形态的能力。
2.特点：
多态有动态多态和静态多态两种：
(1)动态多态（运行时多态）：相同的操作，作用在不同的实例上，产生了不同的结果。要想实现动态多态，还需要向上转型，他们的实例对应的变量都是相同的数据类型（父类的类型）。比如：
Vehicle1 v = new Car();
v.move();
v = new Bike();
v.move(); （改变形态---向上转型一下）。
(2)静态多态（编译时多态）：方法的重载
3.代码举例：
上道题在公共类里也可以这么写
4.推荐文章：多态
四、相关必备知识点
(一).final关键字
1.使用场景
(1)父类中有一些方法禁止子类对其进行改造(不允许重写)。这个时候，我们用final关键字对该方法进行修饰。
(2)有一些类不能有子类，我们可以用final关键字对该类进行修饰，该类为最终类。
2.作用：（面试题）
(1) 修饰类的时候，该类不能被继承（最终类）。
(2) 修饰方法的时候，该方法不能被重写（最终方法）
(3) 修饰成员变量的时候，一旦该成员变量被初始化后，就不能被修改。
什么地方可以修改被final修饰的变量呢？
A. 构造函数
B. 实例块
C. 静态块
D. 声明这个变量的时候可以直接赋值
(4) 修饰局部变量的时候，一旦该局部变量被初始化后，就不能被修改。
(5) 修饰参数的时候，参数不可改变。
3.代码举例：
(二).this关键字
this关键字：指代当前类的对象的引用。
作用：
(1)引用当前对象的成员。
(2)this( 参数列表… ) 进行构造函数之间的调用
(三).super关键字
super关键字：指代父类的引用,用法上与this是对应的
作用：
(1)利用super.成员，对父类的成员进行访问。举个例子如下：
//父类
class Animal{
public String type;//
public void speak() {
System.out.println("不知道啥语言");
}
}
//子类
class Dog extends Animal{
@Override//注解
public void speak() {
super.speak();
System.out.println("小狗都是汪汪地叫");
}
}
运行结果如图所示：
(2)super(参数)，调用父类的构造函数
public class E02 {
public static void main(String[] args) {
//Animal dog= new Dog();//向上转型
//dog.speak();
Dog d= new Dog();//自上而下
}
}
//父类
class Animal{
public String type;//
public Animal() {
System.out.println("动物");
}
}
//子类
class Dog extends Animal{
public Dog() {
//隐藏了super();
System.out.println("狗");
}
}
(四).访问修饰符
1.public：任何地方都可以访问
2.private ：本类可以访问
3.protected：继承关系（可以不同包） 或者 同包
4.package(默认的) ：同包
(五).static关键字
先举个例子，大家理解一下
public class E03 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Student student = new Student();
student=new Student();
student=new Student();
}
}
class Student{
//学生编号正好是学生计数器
public static int sid =0;//成员实例变量
public String sname;
public Student() {
sid++;
System.out.println("第"+sid+"个学生");
}
}
1.添加上静态关键字的成员就叫做静态成员，静态成员有静态成员变量和静态成员方法。静态成员在类加载的时候加载的，静态先后实例，先有类才有对象。
2.静态成员是属于所有对象共享的（类型所共享）。所以，访问的时候，类名.成员名
3.如果不加static关键字就叫做实例成员，他是属于某一个对象的，成员在产生对象的时候产生的。
4.静态成员的常用场景：
(1)撰写工具类的时候，为了简化代码，节约内存。
(2)当你的工具类里面所有的成员都是静态，你需要防止他们产生对象，如何防止？写一个私有的构造函数。例如：Math类
五、面试题总结
1.请你阐述继承？
2.super关键字的作用？
3.访问修饰符有几个？每个都什么意思？
4.final关键字有哪几个个地方可以修饰？