文章目录

面向对象三大特征封装继承多态
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{@Overridepublic 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{//重写@Overridepublic void run() {// TODO Auto-generated method stubsuper.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);}@Overridepublic void show() {// TODO Auto-generated method stubSystem.out.println("我是:"+getName()+" 价格:"+getPrice()+" 大小:"+getSize()+"寸");}}

海鲜披萨类：

//海鲜披萨
class SeafoodPizza extends Pizza{public SeafoodPizza(String name, double price, int size) {super(name,price,size);}@Overridepublic void show() {// TODO Auto-generated method stubSystem.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{@Overridepublic 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{@Overridepublic void word(Drink drink) {if (drink instanceof Water) {Water water=(Water)drink;System.out.println("您买矿泉水");}}
}
//可乐
class Coke extends Drink{@Overridepublic 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);}}}