Java基础—封装继承多态(详细)
文章目录
- 面向对象三大特征 封装 继承 多态
- 1.封装
- 2.继承
-
- 2.1注意事项
- 参考文档
- 2.2 this和super关键字
- 2.3 重载和重写
- 3.多态
-
- 3.1方法的多态
- 3.2对象的多态
- 3.3多态转型
-
- 3.3.1向上转型
- 3.3.2向下转型
- 3.3.3 instanceof 关键字
面向对象三大特征 封装 继承 多态
1.封装
定义:就是把事物封装成类,将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问。
作用:尽可能地隐藏对象的内部实现细节、控制用户对类的修改和访问权限（体现：private属性） 提高代码的可维护性
package com.fengzhuang.kz;
import sun.font.EAttribute;
class Animal{
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
private void eat() {
System.out.println(name+"吃竹子");
}
public void publicEat() {
eat();
}
}
总结: private 声明的属性需要生成public的get，set方法来从外部调用(方法也需要)
2.继承
关键字：extends
格式: class 子类 extends 父类{ }
定义:继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力 俗称子类继承父类
注意:Java只支持单继承 ,一个子类只能继承一个父类,不能继承多个父类 但是可以多重继承
package com.fengzhuang.kz;
//不能多继承
//爷爷类
class A{
}
// 父类
class B extends A{
}
//多重继承 孙子类
class C extends B{
}
2.1注意事项
1.成员变量（属性）
公开的和默认的成员变量，子类是可以继承使用的
私有的成员变量，子类是无法使用
2.成员方法
公开的和默认的成员方法，子类是可以继承使用的
私有的成员方法，子类是无法使用
3.构造器
先执行父类的构造方法，然后再执行子类的构造方法
如果父类里面没有无参构造，子类就不能写无参构造
package com.fengzhuang.kz;
import sun.font.EAttribute;
//父类
class Animal{
private String name;
private int age;
private char sex;
//创建子类对象会调用父类构造器 父类早于子类
public Animal() {
System.out.println("我是父类无参构造器");
}
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;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
private void eat() {
System.out.println(name+"吃竹子");
}
public void publicEat() {
eat();
}
}
//子类
class Panda extends Animal{
@Override
public void publicEat() {
//重写父类的方法
System.out.println("重写");
}
//方法的重载
public void eat() {
}
public void eat(String name) {
}
}
public class Demo01 {
public static void main(String[] args) {
//通过子类对象调用父类属性 方法
Panda panda=new Panda();
panda.setName("国宝");
panda.publicEat();
}
}
练习:编写一个Java应用程序，设计一个汽车类Vehicle，包含的属性有车轮个数wheels和车重weight。小车类Car是Vehicle的子类，其中包含的属性有载人数loader。卡车类Truck是Car类的子类，其中包含的属性有载重量payload。每个类都有构造方法和输出相关数据的方法。最后，写一个测试类来测试这些类的功能
package com.fengzhuang.kz; class Vehicle{ private int wheels;//车轮 private double weight;//车重 public Vehicle() { } public int getWheels() { return wheels; } public void setWheels(int wheels) { this.wheels = wheels; } public double getWeight() { return weight; } public void setWeight(double weight) { this.weight = weight; } } class Car1 extends Vehicle{ private int loader;//有载人数 public Car1() { } public int getLoader() { return loader; } public void setLoader(int loader) { this.loader = loader; } } class Truck extends Car1{ private int payload;//载重量 public void Truck() { } public int getPayload() { return payload; } public void setPayload(int payload) { this.payload = payload; } public void Info(Truck truck) { System.out.println("卡车重量:"+truck.getWeight()+"吨"); System.out.println("卡车载重:"+truck.getPayload()+"kg"); System.out.println("有载人数:"+truck.getLoader()+"人"); System.out.println("车轮有: "+truck.getWheels()+"个"); } } public class Demo07 { public static void main(String[] args) { Truck truck=new Truck(); truck.setWeight(5); truck.setPayload(200); truck.setLoader(2); truck.setWheels(8); truck.Info(truck); } }
输出结果:
参考文档
2.2 this和super关键字
详细请看：this和super的作用
2.3 重载和重写
详细请看：Java重载和重写
3.多态
多态：是多种状态，是面向对象的三大特性之一，多态建立在封装和继承之上
3.1方法的多态
package com.duot.k;
class Person{
public void run() {
}
}
//方法的多态
class Man extends Person{
//重写
@Override
public void run() {
// TODO Auto-generated method stub
super.run();
}
}
3.2对象的多态
1.
父类的引用执行子类的对象2.
编译看左 运行看右3.一定要有继承和重写
//父类 子类
//编译看左 执行看右
Person person=new Man();
案例：
编写程序实现比萨制作。需求说明编写程序，可供选择的比萨有：培根比萨和海鲜比萨。
实现思路及关键代码
分析培根比萨和海鲜比萨
定义比萨类
属性：名称、价格、大小
方法：展示
定义培根比萨和海鲜比萨继承自比萨类
定义比萨工厂类，根据输入信息产生具体的比萨对象
PizzaFactory {
createPizza(Pizza);//如果传的参数培根披萨就是生产培根披萨 如果传的是海鲜披萨就是生产的海鲜披萨
}
披萨类：
class Pizza{
private String name;
private double price;
private int size;
public Pizza(String name, double price, int size) {
this.name = name;
this.price = price;
this.size = size;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getSize() {
return size;
}
public void setSize(int size) {
this.size = size;
}
public void show() {
System.out.println("我是:"+name+" 价格:"+price+" 大小:"+size+"寸");
}
}
培根披萨类：
//培根披萨
class BaconPizza extends Pizza{
public BaconPizza(String name, double price, int size) {
super(name,price,size);
}
@Override
public void show() {
// TODO Auto-generated method stub
System.out.println("我是:"+getName()+" 价格:"+getPrice()+" 大小:"+getSize()+"寸");
}
}
海鲜披萨类：
//海鲜披萨
class SeafoodPizza extends Pizza{
public SeafoodPizza(String name, double price, int size) {
super(name,price,size);
}
@Override
public void show() {
// TODO Auto-generated method stub
System.out.println("我是:"+getName()+" 价格:"+getPrice()+" 大小:"+getSize()+"寸");
}
}
披萨工厂类:
class PizzaFactory {
//如果传的参数培根披萨就是生产培根披萨 如果传的是海鲜披萨就是生产的海鲜披萨
public void createPizza(Pizza pizza) {
pizza.show();
}
}
实现类:
public class Demo02 {
public static void main(String[] args) {
PizzaFactory pizzaFactory=new PizzaFactory();
Pizza baconPizza=new BaconPizza("培根披萨",200,5);
Pizza seafoodPizza=new SeafoodPizza("海鲜披萨",300,6);
pizzaFactory.createPizza(baconPizza);
pizzaFactory.createPizza(seafoodPizza);
}
}
3.3多态转型
3.3.1向上转型
本质就是:父类的引用指向子类的对象
语法格式:父类的对象 变量 = new 子类对象;
class Person {
public void eat () {
System.out.println("父类吃饭");
}
}
class Student extends Person{
@Override
public void eat() {
System.out.println("子类吃饭");
}
//子类独有的方法
public void sleep () {
System.out.println("子类睡觉");
}
}
public class Demo1 {
public static void main(String[] args) {
//父类的引用指向子类的对象
Person person = new Student();
person.eat();//子类的方法
//父类的引用不能执行子类的独有的方法
//person.sleep();
//如果多态中的父类引用指向子类的对象的时候必须得有继承和重写
}
}
3.3.2向下转型
语法格式:
父类类型 父类的引用 = new 父类();
子类类型 引用变量 = 父类的引用;
大转小 需要强制类型转换
经典案例:
class Monkey {
//Object 是所有类的父类
public void Test (Object obj) {
//向下转型
String str = (String)obj;
System.out.println(str);
}
}
public class Demo {
public static void main(String[] args) {
Monkey monkey = new Monkey();
monkey.Test("test");
}
}
总结:向下转型的时候，先向上转型
3.3.3 instanceof 关键字
instanceof : 比较操作符，返回值是一个布尔类型的数据 目的是在强转的时候不会出现异常
语法格式：
注意：
对象的引用必须是运行类本类的对象，或者是子类的对象对象的引用 instanceof 运行类型 Object obj = new object() obj instanceof String false
案例:
/*
* 编写程序实现软料购买：编写程序，接收用户输入的信息，
* 选择购买的饮料。可供选择的饮料有：咖啡、矿泉水和可乐。
* 其中，购买咖啡时可以选择 ：加糖、加奶还是什么都不加。
* 购买可乐时可以选择：买可口可乐还是百事可乐。
*/
class Drink{
Scanner scanner;
public void word(Drink drink) {
}
}
//咖啡
class Coffee extends Drink{
@Override
public void word(Drink drink) {
if (drink instanceof Coffee) {
Coffee coffee=(Coffee)drink;
scanner=new Scanner(System.in);
System.out.println("您要的咖啡加糖还是加奶，还是什么都不加");
String string=scanner.nextLine();
if ("加糖".equals(string)) {
System.out.println("您要的咖啡加糖");
}
else if ("加奶".equals(string)) {
System.out.println("您要的咖啡加奶");
}
else {
System.out.println("你什么都不要");
}
}
}
}
//矿泉水
class Water extends Drink{
@Override
public void word(Drink drink) {
if (drink instanceof Water) {
Water water=(Water)drink;
System.out.println("您买矿泉水");
}
}
}
//可乐
class Coke extends Drink{
@Override
public void word(Drink drink) {
if (drink instanceof Coke) {
Coke coke=(Coke)drink;
Scanner scanner1=new Scanner(System.in);
System.out.println("买可口可乐还是百事可乐");
String string1=scanner1.nextLine();
if ("可口可乐".equals(string1)) {
System.out.println("您要的可口可乐");
}
else {
System.out.println("您要的百事可乐");
}
}
}
}
public class Demo04 {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.println("你要咖啡还是可乐还是矿泉水:");
String string=scanner.nextLine();
if ("咖啡".equals(string)) {
Drink drink=new Coffee();
drink.word(drink);
}
if ("可乐".equals(string)) {
Drink coke=new Coke();
coke.word(coke);
}
if ("矿泉水".equals(string)) {
Drink drink=new Water();
drink.word(drink);
}
}
}
class Demo04 {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.println("你要咖啡还是可乐还是矿泉水:");
String string=scanner.nextLine();
if ("咖啡".equals(string)) {
Drink drink=new Coffee();
drink.word(drink);
}
if ("可乐".equals(string)) {
Drink coke=new Coke();
coke.word(coke);
}
if ("矿泉水".equals(string)) {
Drink drink=new Water();
drink.word(drink);
}
}
}
