Java面向对象三大特性之继承多态的预习笔记,are you ready? 面对疾风吧!
文章目录
- 继承(extends)
- super关键字
- 方法重写
- instanceof关键字
- abstract关键字
- 接口(interface)
- 多态
继承(extends)
AextendsB
A继承了B,B是A的基类、父类(superclass)、超类,A是B的子类
继承注意事项:
子类可以继承父类的成员,但是不要为了减少重复代码而去继承,必须要有继承关系
public class AnimalTest {public static void main(String[] args) {// 实例化DogDog dog = new Dog();// 对对象中的属性进行赋值dog.name = "哈斯奇";// 访问对象中的属性System.out.println(dog.name); // null int age = dog.age;System.out.println(age); // 0dog.color = "白色";String str = dog.color;System.out.println(str);dog.run();} } class Dog extends Animal{} class Animal {int age;String name;String color;public void run() {System.out.println(this.name + "动物正在跑......");} }
父类的私有成员不能被继承.
public class AnimalDemo {public static void main(String[] args) {Bird bird = new Bird();// bird.color = "百色";System.out.println(bird.color); // 彩色bird.color = bird.getColor1();System.out.println(bird.color);} }class Bird extends Animal1 {public Bird() {System.out.println("调用子类类无参构造");// this.name = 12; 访问不到color = "彩色";}public Bird(String color) {System.out.println("调用了子类的带参构造");this.color = color;} }class Animal1 {private String name ;String color;private String getColor() {return color;}public String getColor1() {return "黑色";}public Animal1(String name , String color) {this.name = name;this.color = color;}public Animal1(String color) {System.out.println("调用父类带参构造");this.name = name;}public Animal1() {System.out.println("调用父类无参构造");this.name = "爱情鸟";this.color = "白色";}}
父类的构造方法不能被继承
创建子类对象时会先调用父类的无参构造器,然后再去调用子类的构造器
调用父类的构造器作用 : 为了初始化从父类继承下去的属性
super关键字
super关键字:代表的是父类的引用空间
作用:
如果子父类存在同名的成员时,在子类中默认是访问子类的成员,可通过super关键字指定访问父类的成员
代码展示:
import java.util.Scanner;public class AnimalTest1 {public static void main(String[] args) {// 默认值 : 整型 0 浮点型 0.0 布尔 false 引用 null , 字符 '\u0000'Dog2 dog = new Dog2();dog.name = "你好";Dog2 dog2 = new Dog2();dog.print(); // System.out.println(name + "在吃饭");Scanner input = new Scanner(System.in);System.out.print("请您从键盘输入颜色:");dog.setColor(input .next());String color = dog.getColor();System.out.println(color);} } class Dog2 extends Animal2 {/*String color ;String name;int age;public void print() {System.out.println(name + "动物的名字为" + name + ",年龄为 age = " + age);}* */String name = "12";public void print() {System.out.println("调用了子类的print()的方法");System.out.println(name + "在吃饭");setColor("白色");System.out.println("颜色为" + getColor()); // 颜色为 黑色super.name = "占山";super.print();System.out.println(super.name);super.name = "占山";} } class Animal2 {private String color ;/* private*/ String name;// 父类中的私有成员不能被继承int age;public void setColor(String color) { // 有参无返回值this.color = color;}public String getColor() { // 有返回值无参return color;}public Animal2() {System.out.println("用调用了父类无参构造");name = "你好呀小样";age = 1 ;// color = "黑色";}public void print() {System.out.println("调用了父类的print()方法");System.out.println(name + "动物的颜色为" + color + ",年龄为 age = " + age);} }
在子类中可用super关键字来调用父类中的构造器
代码展示:
public class AnimalTest5 {public static void main(String[] args){Shrap shrap = new Shrap("你好",23,"造成");System.out.println(shrap);} } class Shrap extends Animal3 {public Shrap() {// super();System.out.println("调用了子类的无参构造");}String name ;int age;String color;public Shrap(String name ,int age ,String color) {// super(); // 调用父类无参构造this.name = name ;this.age = age;this.color = color;System.out.println(super.name);System.out.println(super.age);System.out.println(super.color);}@Overridepublic String toString() {return "[ 名字为 name = " + name + ",颜色为 color = " + color + ",年龄为 age = " + age + "]" ;} }class Animal3 {String name; // 默认值为nullString color; // 默认值为nullint age; // 默认值 为 0public Animal3() {System.out.println("调用了父类中无参构造");this.name = "niha1";this.age = 1;this.color = "black";}public Animal3(String name ,int age ,String color) {System.out.println("调用了父类的带参构造");this. name = name ;this.age = age;this.color = color;} }
注意:
super关键字用来在子类中调用父类构造器时,必须是构造体中的第一条语句
this和super调用构造器时,不能同时出现在同一个构造体中
代码展示:
public class AnimalTest06 {public static void main(String[] args) {Cat cat = new Cat("你是","谁呀",45);System.out.println(cat.name);} } class Animal4 {String name ;String str ;int age;public Animal4() { // 构造器名 必须和类名 保持一致System.out.println("调用父类的无参构造....");name = "name" ;age = 12;str = "明天你好";}public Animal4(String name ,String str,int age) {this.age = age ;this.str = str;this.name = name;System.out.println("执行了父类的带参构造");} } class Cat extends Animal4 {String name ;String str;int age;public Cat() {System.out.println("调用了子类无参构造");}// cName = "你是'// cStr = "谁呀"// cAge = agepublic Cat(String cName ,String cStr,int cAge) {// super();// 调用了父类的无参构造this(cName,cStr); // 调用了当前类中带两个参的构造方法// super(cName,cStr,cAge); // 调用了父类中带参构造器System.out.println("调用了子类中三个参数的构造器");System.out.println("调用了子类带三个参构造器");age = cAge;}public Cat(String name ,String str) {System.out.println("调用了子类中两个参数的构造器");this.name = name;this.str = str;} }
方法重写
什么时候进行方法重写? (方法重写的应用场景)
当父类的方法功能无法满足子类需求时,我们就进行方法重写
代码展示:
public class CarFactory {public static void main(String[] args) {BSJ bsj = new BSJ();bsj.run(bsj.name);}
}
class Car {String name;String color;public void run(String name) {System.out.println( name + "四个轮子跑的会很快");}public Car() {System.out.println("调用了父类中的构造器");}
}
class BSJ extends Car {public BSJ() {this.name = "保时捷";this.color = "白色";System.out.println("调用了子类中的构造器");}String name;String color ;// 重写run方法// 子夫类的方法名&&形参必须保持一致public void run(String name) {System.out.println( name + " 我的四个轮子牛逼的很");}
}
前提: 必须有继承关系
要求:
方法重写时,子父类的方法名&&形参&&方法返回值类型必须保持一致
代码展示:
// 子夫类的方法名&&形参必须保持一致public void run(String name) {System.out.println( name + " 我的四个轮子牛逼的很");}// 父类中的方法public void run(String name) {System.out.println( name + "四个轮子跑的会很快");}
方法重写时,子类的权限修饰符 > | = 父类的方法权限修饰符
代码展示:
// 父类中的run方法 private void run(String name) {System.out.println( name + "四个轮子跑的会很快");}// 子类中重写父类中的run方法// 重写run方法public void run(String name) {System.out.println( name + " 我的四个轮子牛逼的很");}
方法重写时,子类的返回值类型 < | = 父类的返回值类型
代码展示:
// 方法重写是,子类的返回值类型 < | = 父类的返回值类型private String run(String name) {return name + "四个轮子跑的会很快";} // 重写run方法,子类重写父类的run方法public void run(String name) {System.out.println( name + " 我的四个轮子牛逼的很");}
方法重写时,子类抛出的异常类型 < | = 父类抛出的异常类型
代码展示:
// 子类抛出的异常类型 = 父类抛出的异常类型 // 父类中的run方法,父类抛出的异常类型也是Exception private String run(String name) throws Exception {return name + "四个轮子跑的会很快";} // 重写父类中的run方法, 子类抛出的异常类型 是Exceptionpublic void run(String name) throws Exception {System.out.println( name + " 我的四个轮子牛逼的很"); }// 子类抛出的异常类型 < 父类抛出的异常类型 // 重写run方法 ,子类抛出的异常类型 NoSuchFieldException public void run(String name) throws NoSuchFieldException {System.out.println( name + " 我的四个轮子牛逼的很"); } // 父类中的run方法,父类抛出的异常类型 private String run(String name) throws Exception {return name + "四个轮子跑的会很快"; }
instanceof关键字
作用:判断一个对象是否属于一个指定的类型
前提:判断的对象&&指定的类型必须有继承关系 (extends)| 实现(implements)关系
使用格式: 对象 instanceof 指定的类型
代码展示:
public class InstanceOfDemo {public static void main(String[] args) {Cat cat = new Cat();boolean flag = cat instanceof Cat;if(flag) {System.out.println("属于");// 输出}else {System.out.println("不属于");}// 判断的对象与指定的类型必须存在实现关系 | 继承关系BSJ bsj = new BSJ();if(bsj instanceof Car) {System.out.println("属于"); // 输出}else {System.out.println("不属于");}/* new Animal();*/if(new Animal() /*对象*/ instanceof Dog /*指定的类型*/ ) {System.out.println("属于");}else {System.out.println("不属于"); // 输出}}
}
abstract关键字
注意细节:
若方法没方法体,那方法必须使用abstract修饰
若类中有抽象方法,那该类必须用abstract修饰
代码展示:
abstract class Animal5 {String name ;String color;public abstract void sleep(); }
非抽象类继承抽象类时,非抽象类必须要实现抽象类中的所有抽象方法
代码展示:
abstract class Animal5 {String name ;String color;public abstract void sleep(); } class Fish extends Animal5 {public void sleep() {System.out.println(name + "在睡觉....");} }
抽象类中可以定义抽象方法和非抽象方法
代码展示:
abstract class Animal5 {String name ;String color;public void println() {System.out.println("name = " + name + "\ncolor = " + color);}public abstract void sleep(); }
抽象类中也可不定义抽象方法
代码展示:
abstract class Animal5 {String name ;String color;public void println() {System.out.println("name = " + name + "\ncolor = " + color);}/*public abstract void sleep();*/ }
抽象类不能实例化,即:抽象类是不能创建对象的
为什么抽象类不能实例化?
答:因为抽象类若实例化了,就可以使用对象去调用抽象方法了,一旦调用了就没有意义了
编译错误截图:
代码展示:
abstract class Animal5 {String name ;String color;public static void print() {System.out.print("你哈" + "好呀");}public void println(String name ,String color) {System.out.println("动物name = " + name + "\ncolor = " + color);}public abstract void sleep();}
抽象类中存在构造器
既然抽象类不能实例化,那存在构造器有何意义?
抽象类的构造器是留给子类调用的,初始化从父类继承下去的属性的
代码展示:
abstract class Animal5 {String name ;String color;public static void print() {System.out.print("你哈" + "好呀");}public void println(String name ,String color) {System.out.println("动物name = " + name + "\ncolor = " + color);}public abstract void sleep();public Animal5() {System.out.println("调用了抽象类中无参构造");}public Animal5(String name){System.out.println("调用了抽象类中带一个参的构造器");this.name = name;}public Animal5(String name ,String color) {this(name); // 调用本类中的带一个参数的构造器System.out.println("调用了抽象类中带两个参构造");this.color = color;} }
接口(interface)
作用:
- 程序的解耦(低耦合高内聚)
- 定义约束
- 拓展功能
接口定义格式:
代码展示:
// 接口定义格式如下: interface 接口名 { ...... }
注意事项:
在接口中的变量都是自定义常量,修饰符必须是public static final
/*public static final*/ int name = 0 ;
在接口中的方法都是抽象方法,修饰符是public abstract
/*public abstract*/ void clear();
接口不能实例化,接口可以声明变量
接口没有构造器
原因:因为接口中变量都是自定义常量,接口中的方法都是抽象方法
若一个非抽象类实现接口时,必须实现接口中的所有方法
实现接口的格式:
public class 类名 implements 接口1,接口2,接口3.....{}
代码展示:
class UserDao implements Dao {@Overridepublic User find() {return new User("张三",11,"创智博客创新科技园",13886952615L);}@Overridepublic void delbyId(int id) {System.out.println("删除成功~~");}@Overridepublic void update(int id) {System.out.println("更新成功~~");}@Overridepublic void add(User user) {System.out.println("添加成功");} } interface Dao {User find();void delbyId(int id);void update(int id);void add(User user); }
接口&&类的关系: 实现关系
注意细节:
非抽象类实现一个接口时,必须实现该接口中的所有方法
一个类可以实现多个接口
public class 类名 implements 接口1,接口2,接口3.....{// 实现接口中的方法 }
问:java支持多实现接口,为什么不支持多继承呢?
若支持多继承,假设多个父类中有相同成员,那子类就不知道要调用哪个同名成员了.
抽象类实现接口时,可实现接口中方法,也可以不实现
代码展示:
public class UserServiceTest {public static void main(String[] args) {Dao dao = new UserDao();} } abstract class UserServiceImpl implements Service {public void addUser(){System.out.println("添加成功");}public void delUser() {System.out.println("删除成功");}} interface Service {void addUser();void delUser();User findUser();void updateUser(); }
多态
所谓多态?多态就是一个对象多种形态
即:父类引用类型变量指向了子类对象或者接口引用类型变量指向了实现类对象
多态的前提: 必须存在继承 | 实现关系
继承关系下的多态
父类类型 变量名 = new 子类对象();
比如:
Animal animal = new Dog();
多态的注意事项:
- 在多态情况下,子父类存在同名的成员变量时,默认会访问父类的成员变量
- 在多态情况下,子父类存在同名的非静态方法时,默认是调用子类的非静态方法
- 在多态情况下,子父类存在同名的静态方法时,默认是调用父类的静态方法
- 在多态情况下,不能直接访问子类特有的成员,若要访问,需要强转
总结:多态情况下,子父类存在同名的成员时,默认都会访问父类的成员,只有存在非静态同名方法时,才会方法调用子类的非静态方法,若要在多态情况下调用到子类的特有的成员,那么必须进行强制类型转换
多态的应用场合:
- 多态用于形参类型时,可接受更多类型的参数
- 多态用于返回值类型时,可接受更多类型的参数
多态的好处:提高了程序的可拓展性
代码展示:
public class AnimalTest4 {public static void main(String[] args) {Animal6 animal = new Snake("眼睛蛇", "白色",12.2);// 多态情况下,子父类存在同名变量是,默认会方法父类的成员变量System.out.println(animal.name);// 多态情况下,子父类存在同名的非静态方法时,默认值会先调用子类中非静态方法animal.play(); // 调用子类中的play()方法// 多态情况下,子父类存在同名的静态方法时,默认是调用父类的静态方法animal.print(); // 父类中的静态print()方法Animal6.print(); // 父类中的静态print()方法// 多态情况下,不能直接访问子类中特有的属性,若要访问,需要强转Snake animal1 = (Snake) animal;animal1.length = 1574;System.out.println(animal1.length); // 12.2// println(new Snake("蟒蛇","中色",100));println(new Snake("蟒蛇","中色",100));Animal6 println = println();Snake println1 = (Snake) println;// 在多态情况下不能访问子类中特有的属性,若要访问,需要强转System.out.println(println1.length);}public static void println(Animal6 animal) {System.out.println(animal);}public static Animal6 println() {return new Snake("小鸡鸡","黑色",12);}}
class Animal6 {// 属性String name ;String color;// 编写成员方法public void run() {System.out.println(name + "什么动物正在跑");}public void eat() {System.out.println(name + "动物正在吃东西.... ");}public void sleep() {System.out.println(name + "动物正在睡觉....");}// 编写get 和set方法public String getName() {return name;}public void setName(String name) {this.name = name;}public String getColor() {return color;}public void setColor(String color) {this. color = color;}// 无参构造器public Animal6() {System.out.println("调用了父类的无参构造");}// 带参构造器public Animal6(String name ,String color ) {System.out.println("调用父类的带惨构造");this.name = name ;this.color = color;}// toString()方法public String toString() {System.out.println("调用了父类中toString()方法");return "[ name = " + name + ",color = " + color + "]";}public void play() {System.out.println(name + "动物们正在开开心心的玩耍");}public static void print() {System.out.println("父类中的静态print()方法");}
}
class Snake extends Animal6 {// 特有属性double length;String name;String color;public Snake() {System.out.println("调用了子类的构造方法" );}public Snake(String name ,String color) {System.out.println("调用了子类的带参构造");this.name = name ;this.color = color;}public Snake(String name ,String color,double length) {// super(name ,color); // 调用了父类的无参构造this(name,color);System.out.println("调用了子类的带参构造");this.length = length;}public void play() {System.out.println("调用子类中的play()方法");}public static void print() {System.out.println("子类中的静态print()方法");}public String toString() {return "[ name = " + name + ",color = " + color + ",length = " + length + "]";}
}
实现关系下的多态
接口引用数据类型 变量名 = new 实现类对象();
比如:
Dao userDao = new UserDao();
代码展示:
public class UserDaoTest {public static void main(String[] args) {Dao userDao = new UserDao();User user = userDao.find();System.out.println(user);}
}
class UserDao implements Dao {@Overridepublic User find() {return new User("张三",11,"创智博客创新科技园",13886952615L);}@Overridepublic void delbyId(int id) {System.out.println("删除成功~~");}@Overridepublic void update(int id) {System.out.println("更新成功~~");}@Overridepublic void add(User user) {System.out.println("添加成功");}
}
interface Dao {User find();void delbyId(int id);void update(int id);void add(User user);
}
Java面向对象三大特性之继承多态的预习笔记,are you ready? 面对疾风吧!相关推荐
- 深入理解Java面向对象三大特性 封装 继承 多态
1.封装 封装的定义: 首先是抽象,把事物抽象成一个类,其次才是封装,将事物拥有的属性和动作隐藏起来,只保留特定的方法与外界联系 为什么需要封装: 封装符合面向对象设计原则的第一条:单一性原则,一个类 ...
- Java面向对象三大特性(封装继承多态)解释及案例
文章目录 包 包基本语法 命名规则 命名规范 导入包实例 访问修饰符 面向对象编程-封装 面向对象编程-继承 super关键词 super和this的比较 方法重写/覆盖 (override) 注意事 ...
- java 面向对象三大特性之继承 万字详解(超详细)
目录 前言 : 一.为什么需要继承: 二.什么是继承(Warning : 篇幅较长)? 1.继承概述: 2.子类继承父类之后达到的效果 : ①如何使用继承? ②代码演示 : 3.继承的使用场景: eg ...
- Day55-每日一道Java面试题-Java 面向对象编程三大特性: 封装 继承 多态
Java 面向对象编程三大特性: 封装 继承 多态 封装 封装把一个对象的属性私有化,同时提供一些可以被外界访问的属性的方法,如果属性不想被外界访问,我们大可不必提供方法给外界访问.但是如果一个类没有 ...
- 【职坐标】java面向对象三大特性(二)——继承详解
[职坐标]java面向对象三大特性(二)--继承详解 a) 什么是继承? i. 多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那个类即可 b) ...
- java 面向对象三大特性之多态 万字详解(超详细)
目录 前言 : 一.为什么需要多态 : 1.白璧微瑕 : 2.举栗(请甘雨,刻晴,钟离吃饭): 3.代码 : 4.问题 : 二.什么是多态 : 1.定义 : 2.多态的实现步骤(重要) : 三.多态的 ...
- 大数据必学Java基础(四十):面向对象三大特性之一继承(Inheritance)
文章目录 面向对象三大特性之一继承(Inheritance) 一.列举案例说明 1.类是对对象的抽象
- 夯实Java基础系列1:Java面向对象三大特性(基础篇)
本系列文章将整理到我在GitHub上的<Java面试指南>仓库,更多精彩内容请到我的仓库里查看 https://github.com/h2pl/Java-Tutorial 喜欢的话麻烦点下 ...
- 【转】java提高篇(二)-----理解java的三大特性之继承
[转]java提高篇(二)-----理解java的三大特性之继承 原文地址:http://www.cnblogs.com/chenssy/p/3354884.html 在<Think in ja ...
最新文章
- lnmp环境如何添加域名和虚拟主机
- r语言解释回归模型的假设_模型假设-解释
- iphone、Android接收System.Net.Mail发的邮件标题乱码
- Linux内核设计与实现---虚拟文件系统
- 辽宁沈阳计算机学校王斯琪,青春正好,理所当“燃”——沈阳万合技校开展2020-2021年度春季学期跳大绳比赛...
- VB6 如何连接MYSQL数据库
- 大前端时代下,如何成为一名优秀的程序员?
- 编程语言和shell编程的基础内容以及grep、egrep命令及相应的正则表达式和用法...
- string-indexOf、substring、split
- 「福利」Java Swing 编写的可视化算法工程,包含树、图和排序
- nowcoder猜想c语言筛子,剑指 Offer 50 道经典算法题视频讲解
- 角度计算公式 角度换算 想知道1是多少度; 度和弧度的关系 弧微分: 曲率,曲半径,曲率圆:
- python做三维图片挑战眼力_查找「儿童大家来找茬图片」安卓应用 - 豌豆荚
- 为什么要用同花顺程序化交易接口
- 苹果Mac优化清理工具CleanMyMac X2023版本
- 捋一捋Python中的List(上)
- Java学习(84)Java集合——案例:公告管理(ArrayList增删改查)
- C语言冒泡排序(从大到小排序核心代码)
- SQLServer中uniqueidentifier数据类型理解
- 百度云android平板,百度网盘hd版本下载-百度网盘hd平板版本下载v11.6.3 安卓官方版-2265安卓网...
热门文章
- python实战运用_Python实战应用开发 - 安全牛课堂 - 领先的信息安全在线教育平台...
- 简述改变计算机桌面背景的方法,win7开关机背景图怎么更换_win7电脑换开关机壁纸图片的方法...
- 为什么C语言能长盛不衰?
- 计算机毕业设计(附源码)python中国朝鲜族民族特色服务系统
- 2021-西方哲学精神探源-期末考试题答案
- 照片视频字体音频配色简历ppt免费素材
- 解决M1芯片Mac 黑屏PhotoShop 2019
- 超融合一体流式引擎,打造分布式数据库新纪元
- Ocelot API 网关Nacos 服务发现
- kali连不上网络问题