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{@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);}}}
Java基础—封装继承多态(详细)相关推荐
- (十)Core Java 面向对象(封装,继承,多态,接口) -02 (96)
目录 : 24 ). 面向对象(聚集关系) 25 ). 面向对象(子父类中变量的特点) 26 ). 面向对象(子父类中函数的特点-覆盖) 27 ). 面向对象(子父类中构造函数的特点 ...
- Java的封装继承多态简介与实例
封装 所谓封装就是访问权限控制,不允许调用者直接访问类的属性,使用private修饰,将属性藏起来 此时若创建对象,直接修改属性值,则会报错 想要对属性进行读写则需要在类中添加get/set方法 此时 ...
- Java基础---封装继承静态
封装&this关键字&静态 封装 封装:隐藏事物的属性和实现细节,并对外提供公开的访问方式. 属性私有化:private 可修饰的内容:成员变量.成员方法.构造方法.内部类被priva ...
- c语言编程 菲薄拉,C语言设计模式-封装-继承-多态
快过年了,手头的工作慢慢也就少了,所以,研究技术的时间就多了很多时间,前些天在CSDN一博客看到有大牛在讨论C的设计模式,正好看到了,我也有兴趣转发,修改,研究一下. 记得读大学的时候,老师就告诉我们 ...
- 大数据笔记8—java基础篇4（面向对象-封装-继承-多态）
面向对象 一.面向对象 1.面向过程 1.2.举例 1.3.总结 二.面向对象 1.简述 2.举例 3.思想特点 2.1.类的定义格式 2.1.1.简述 2.2.2.格式 2.3.3.示例 三.类的使 ...
- Java继承_Hachi君浅聊Java三大特性之 封装 继承 多态
Hello,大家好~我是你们的Hachi君,一个来自某学院的资深java小白.最近利用暑假的时间,修得满腔java语言学习心得.今天小宇宙终于要爆发了,决定在知乎上来一场根本停不下来的Hachi君个人 ...
- Day55-每日一道Java面试题-Java 面向对象编程三大特性: 封装 继承 多态
Java 面向对象编程三大特性: 封装 继承 多态 封装 封装把一个对象的属性私有化,同时提供一些可以被外界访问的属性的方法,如果属性不想被外界访问,我们大可不必提供方法给外界访问.但是如果一个类没有 ...
- Java基础篇--继承(inherit),多态(Polymorphism)
Java基础篇--继承(inherit),多态(Polymorphism) 1. 继承概述 1.1 什么是继承 1.2 为什么要使用继承 1.3 继承的特点 1.4 继承的优点 2. 组合设计模式 2 ...
- 靠java_基础不牢靠，何以争朝夕？Java基础面试82道详细解析！（一）
基础不牢靠,何以争朝夕?Java基础面试82道详细解析!(一) 发布时间:2020-03-31 12:08:31 来源:51CTO 阅读:229 作者:wx5d9ed7c8443c3 题目的基本顺序是 ...
- 小白理解——封装继承多态
一.封装 是什么:首先是抽象,把事物抽象成一个类,其次才是封装.对外表示为一个对象,隐藏对象的属性和动作实现的细节,仅对外公开接口. ...
最新文章
- R中rJava包载入时报错的问题
- (char*)malloc(sizeof(char))有什么用，为什么要这么写——简单介绍指针
- Organization Unit buffer - OOATTRCUST
- 前端性能优化篇——浏览器http同域名并发请求对限制
- Tomcat7实现Servlet3异步请求
- 三次技术转型，程序员的北漂奋斗史
- FastReport studio 动态加载数据集 (zhuan)
- matlab中dfft,2-DFFT 该实验的目的是开发一个 2-D FFT程序包 联合开发网 - pudn.com
- ie8兼容性视图灰色修复_【ie8兼容性视图灰色修复】ie8兼容性视图 灰色_ie8兼容性视图设置...
- Cortex-M0 Devices introduction
- 计算机类公务员提升空间,本人在公务员省考裸考申论61分，在之后还有多大的提升空间？...
- 去哪下载python项目_Python 项目实践二（下载数据）第三篇
- 一卡通(M1卡)破解过程记录——理论篇
- [Android]进程通信Andromeda框架
- 用Python Matplotlib实现可视化混沌系统
- linux内核中锁有哪些,Linux内核中有哪些锁
- Web安全第 01 讲：渗透测试方法论
- 世界上各种壮观震撼奇景。也许你这辈子都看不到了!
- 《巴黎协定》生效 光伏被视为未来主流能源
- Could not initialize class JDBC.JDBCUtils 已解决