1. IT分享知识网首页

封装 继承 多态_封装继承多态面试

老牧童 • • 未分类 • 阅读 89

封装 继承 多态_封装继承多态面试封装面向对象三大特征[^封装、继承、多态]:**1.概述：**是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。核心是：归纳总结**2.好处：**提高代码的复用度、安全性，不必关心具体细节，便于开发JavaBean规范化封装要求：Java中的所有实体类成员变量全部私有化，最少提供一

大家好，欢迎来到IT知识分享网。

封装

面向对象三大特征

1.概述：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。核心是：

归纳总结

2.好处：提高代码的复用度、安全性，不必关心具体细节，便于开发

JavaBean规范化封装

要求：Java中的所有实体类成员变量全部私有化，最少提供一个无参构造方法，对应成员变量实现setter和getter方法

1. JavaBean规范，是为了后期开发汇总更好的代码适配度，提高代码运行的统一性，能够满足框架的使用
2. JavaBean规范只是一个规范，而且是作为一个基础规范，操作都是可以使用快捷键来完成的！！！

class Person {
   // 成员变量全部私有化
	private String name;
	private int age;
	private char sex;
	private boolean alive;
	//无参构造方法
	public Person() {}
	//对应成员变量实现setter和getter方法
	public String getName() {
		return this.name;
	}
	
	public int getAge() {
		return this.age;
	}
	
	public char getSex() {
		return this.sex;
	}
	
	public boolean isAlive() {
		return alive;
	}
	
	public void setAlive(boolean alive) {
		this.alive = alive;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
	
	public void setSex(char sex) {
		this.sex = sex;
	}
}

类与类之间的调用（多类合作）

汽车类：

package com.hw.zsy.OctNineteenth;

public class Car {
	private String color;
	private float speed;
	private String brand;
	private int tyreTotal;// 轮胎个数
	private Engine engine;
	
	public Car() {
	}
	
//	public Car(String color, float speed, String brand, int tyreTotal) {
//		this.color = color;
//		this.speed = speed;
//		this.brand = brand;
//		this.tyreTotal = tyreTotal;
//	}

	public Car(String color, float speed, String brand, int tyreTotal) {
		this.color = color;
		this.speed = speed;
		this.brand = brand;
		this.tyreTotal = tyreTotal;
		this.engine = new Engine("XX", 1.0F);
	}

	// 飙车方法
	public void race() {
		if (4 == tyreTotal) {
			System.out.println("开着" + color + "的" + brand + "以" + speed + "迈的速度飙车");
		} else {
			System.out.println("轮胎出问题了，要找修理厂");
		}
	}

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}

	public float getSpeed() {
		return speed;
	}

	public void setSpeed(float speed) {
		this.speed = speed;
	}

	public String getBrand() {
		return brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
	}

	public int getTyreTotal() {
		return tyreTotal;
	}

	public void setTyreTotal(int tyreTotal) {
		this.tyreTotal = tyreTotal;
	}

	public Engine getEngine() {
		return engine;
	}

	public void setEngine(Engine engine) {
		this.engine = engine;
	}
   
}

汽车测试类：

package com.hw.zsy.OctNineteenth;

public class CarDemo {
 public static void main(String[] args) {
	       // 准备一辆车
			Car car = new Car("红色", 300.0F, "法拉利", 4);
	       // 飙车
			for (int i = 0; i < 10; i++) {
				float speed = car.getSpeed() + 2;
				car.setSpeed(speed);
				car.race();
			}
			// 如果车的速度太快，达到了320迈。会爆胎
			if (car.getSpeed() >= 320.0F) {
				// 轮胎少了一个，说明有一个轮胎爆掉了
				car.setTyreTotal(3);
			}
			car.race();
			Factory factory = new Factory("滚王子修车厂", "15844517927", "吉安");
			Car fixedCar = factory.fix(car);
			// 飙车
			for (int i = 0; i < 10; i++) {
				float speed = fixedCar.getSpeed() + 2;
				fixedCar.setSpeed(speed);
				fixedCar.race();
			}
		}
}

引擎类：

package com.hw.zsy.OctNineteenth;

public class Engine {
	private String brand; // 型号
	private float displacement;// 排量

	public Engine() {
	}

	public Engine(String brand, float displacement) {
		this.brand = brand;
		this.displacement = displacement;
	}

	public String getBrand() {
		return brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
	}

	public float getDisplacement() {
		return displacement;
	}

	public void setDisplacement(float displacement) {
		this.displacement = displacement;
	}
}

工厂类：

package com.hw.zsy.OctNineteenth;

public class Factory {
	private String name;
	private String tel;
	private String address;

	/**
	 * 修车方法，需要一辆坏车，修好我给你一辆好车
	 * 
	 * @param car 传入需要被修理的坏车
	 * @return 返回修好的车
	 */
	public Car fix(Car car) {

		showStart();

		Car fixedTyreCar = fixTyre(car);
		
		Car fixedEngineCar = fixEngine(fixedTyreCar);
		
		showEnd();

		return fixedEngineCar;
	}

	/*
	 * 欢迎
	 */
	public void showStart() {
		System.out.println("欢迎来到" + this.getName() + "修车厂，我们的电话是：" + this.getTel() + "，我们的地址是：" + this.getAddress());
	}

	/**
	 * 修理轮胎的方法
	 * 
	 * @param car 传入一个车
	 * @return 修好轮胎的车
	 */
	public Car fixTyre(Car car) {
		if (car.getTyreTotal() != 4) {
			car.setTyreTotal(4);
			car.setSpeed(80.0F);
			System.out.println("修车ing");
		}
		return car;
	}

	/**
	 * 修理引擎的方法
	 * @param car 传入一辆要被修理的车
	 * @return 返回一个修好引擎的车
	 */
	public Car fixEngine(Car car) {
		// 创建一个新的引擎
		Engine newEngine = new Engine("性能怪兽新引擎", 2.0F);	
		car.setEngine(newEngine);
		return car;
	}
	
	/*
	 * 给钱方法
	 */                                                                                                                
	public void showEnd() {
		System.out.println("车修好了，给钱钱钱钱钱钱钱钱钱钱钱钱钱钱钱钱钱钱");
	}
    //无参构造方法
	public Factory() {
	}
    //三参构造方法
	public Factory(String name, String tel, String address) {
		this.name = name;
		this.tel = tel;
		this.address = address;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getTel() {
		return tel;
	}

	public void setTel(String tel) {
		this.tel = tel;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}
}

继承

1、概念

把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系，这多个类就具备了这些内容。这个关系叫继承。

2、格式

关键字：extends

格式:
	class Son extends Father {
    
	}

一个孩子只能有一个父亲
一个父亲可以有多个孩子

3、特点

（1）Java为单继承，一个类只能有一个直接父类，但可以多级继承，属性和方法逐级叠加。
（2）构造方法只可服务于本类，不可继承，子类执行构造方法前会默认调用父类的无参构造方法。可以通过super()去访问父类的构造方法。
（3）private 修饰的属性和方法不能被继承

注意：子类构造方法执行前默认先执行父类的无参构造方法

4、优点

（1）提高了代码的复用性
（2）提高了代码的维护性
（3）让类与类之间产生了一个关系，是多态的前提

5、缺点

（1）让类的耦合性增强。这样某个类的改变，就会影响到其他和该类相关的类
（2）打破了封装性

6、总结

Java中只有单继承

子类可以继承父类的非私有属性和方法（非private修饰的）

执行子类的构造方法前会默认执行父类的无参构造方法

举例：

extends
public class Demo {
	public static void main(String[] args) {
		// 创建一个父类对象
		Father father = new Father();
		
		// 父类调用父类的属性和方法
		father.name = "父";
		System.out.println(father.name);
		father.game();
		
		System.out.println("-------------");
		
		// 创建一个子类对象
		Son son = new Son();
		
		// 子类调用子类的属性和方法
		son.age = 16;
		System.out.println(son.age);
		son.study();
		
		// 子类调用父类的属性和方法(public修饰)
		son.name = "子";
		System.out.println(son.name);
		son.game();
		
		
		/*
		 * 子类调用父类private修饰的属性和方法
		 * 
		 * 报错
		 * The field Father.suffer is not visible
		 * The method cook() from the type Father is not visible
		 * 
		 * 由此可知子类不能调用父类私有化的属性和方法
		 */
//		son.suffer = 10;
//		son.cook();
	}
}

public class Father {
	public String name;
	
	private int suffer;
	
	public void game() {
		System.out.println("下棋");
	}
	
	private void cook() {
		System.out.println("做饭");
	}
}

public class Son extends Father{
	public int age;
	
	public void study() {
		System.out.println("子类 -- 学习");
	}
}
子类构造方法执行前默认先执行父类的无参构造方法
class Father {
	String name;

	public Father() {
		System.out.println("Father's Constrator be performed");
	}
}

class Son extends Father {
	int age;

	public Son() {
		System.out.println("Son's Constrator be performed");
	}
}

public class TestSon {
	public static void main(String[] args) {
		Son son = new Son();
	}
}
结果：
    Father's Constrator be performed
    Son's Constrator be performed
【注意】
    （1）Son 的构造方法中编译器默认生成 super(); 
    （2）用来调用父类的构造方法，目的是为了初始化父类字段，因为子类可能会用到。

多态

什么是什么

父类引用
引用子类对象

父类和子类有同名的覆盖方法

通过父类引用调用这个重写的方法的时候。多数的话就可以称为多态，单数可以说运行时绑定。

使用多态有什么好处？

类调用者对类的使用成本进一步降低

封装是让类的调用者不需要知道类的实现细节，多态能让类的调用者连这个类的类型是什么都不必知道，只需要知道这个对象具有某个方法即可。因此，多态可以理解成是封装的更进一步，让类调用者对类的使用成本进一步降低。

能够降低代码的“圈复杂度”，避免使用大量的if-else

免责声明：本站所有文章内容,图片，视频等均是来源于用户投稿和互联网及文摘转载整编而成，不代表本站观点，不承担相关法律责任。其著作权各归其原作者或其出版社所有。如发现本站有涉嫌抄袭侵权/违法违规的内容,侵犯到您的权益，请在线联系站长,一经查实,本站将立刻删除。 本文来自网络,若有侵权，请联系删除，如若转载，请注明出处：https://yundeesoft.com/30024.html

赞 (0)
老牧童老牧童
0

相关推荐

发表回复

您的电子邮箱地址不会被公开。 必填项已用 * 标注

关注微信