前言
面向对象三大基本特性:封装,继承,多态,了解更详细的概念可以看这位博主的文章三大特性五大基本原则
提示:以下是本篇文章正文内容,下面案例可供参考
一、封装字段
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关键字有哪几个个地方可以修饰?