文章目录

• 前言
• • 一、封装字段
  • 二、继承
  • 三、多态
  • 四、相关必备知识点
  • 五、面试题总结

前言

面向对象三大基本特性：封装，继承，多态，了解更详细的概念可以看这位博主的文章三大特性五大基本原则

提示：以下是本篇文章正文内容，下面案例可供参考

一、封装字段

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关键字有哪几个个地方可以修饰？