继承,重写,多态,重点往往都是一起跳舞的
文章目录
一、继承
- 继承:父类和子类
- 子类会具有父类的一些功能,可以提高代码的重用性
- 继承是面向对象语言的一种设计思想,
- 提高代码的可重复利用性(儿子可以使用父亲)
- 代码的可扩展性(子类可以有自己的功能)
- 父类(基类)可以把一些共有的属性定义在父类中
- 继承的传递性
C类从B类继承,B类又从A类继承
那么C类就具有B类和A类的所有非私有属性和非私有方法 - 当一个类没有写继承,则他会默认继承Object类
- Object是所有类的基类(父类)也叫超类
1. 继承语法extends关键字
- 语法:
[访问权限修饰符][修饰符] 子类名 extends 父类名{子类体} - java中一个类只能继承一个类
- Cat继承Animal
- Cat类是Animal类的子类
- 子类可以扩展自己的功能
- 专业术语
Cat类是 Animal类的子类, Animal类是Cat类的父类
Cat类是 Animal类的派生类, Animal类是Cat类的基类
private String name;
private int age;
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 void eat(){
System.out.println("动物吃");
}
public static void main(String[] args) {
Cat cat = new Cat();
cat.setName("TOM");
cat.setAge(3);
System.out.println(cat.getAge()+" "+cat.getName());
cat.eat();
cat.setPinzhong("布偶");
cat.jiao();
}
2.关键字supre
- super关键字用途
- super关键字代表父类的引用,在程序中主要的用途
- 在子类构造方法中要调用父类的构造方法,需要注意:super语句只 能出现在子类构造方法体的第一行。
- 用“super.成员变量名”来引用父类成员变量
- 用“super.方法名(参数列表)”的方式访问父类的方法。
- 与this的区别,this通常指代当前对象,super通常指代父类。
public Cat(){
super("哈哈");//如果supre里传入一个参数,则调用Animal中有参的构造方法
System.out.println("Cat的无参的构造方法");
}
/*
一个类可以
调用子类构造方法时,先会调用父类Animal的构造方法
关键字super
构造方法的第一行,默认使用super来调用父类默认无参构造方法,
*/
public void feel(){
System.out.println("Tom会喂杰瑞吃饭");
}
public Tom(){
super();//如果要显示的调用,必须放在构造方法的第一行,先确保分类的调用
System.out.println("Tom类的无参构造方法");
super.eat();//可以通过super来调用父类中的方法
}
3.重写
- 什么时候需要重写:父类的方法不能满足子类的需求
- 方法的重写:当子类中的实现与父类中的不同时,可以在子类中将父类中的方法重写(覆盖/复写)
- 要求:
- 子类方法的结构必须与父类相同
- 子类重写后的访问权限必须大于等于父类的访问权限
- 要求:
- 标签
- @Override 标签
- 表示此方法是重写过的
//父类
public void eat(){
System.out.println("动物吃");
}
//子类:
@Override
public void eat(){
System.out.println("Tom爱吃小鱼干");
}
//测试类
public static void main(String[] args) {
Tom tom = new Tom(); //这是相当于创建了Tom的对象,Cat的对象,Animal的对象,Object的对象
tom.eat();
}
4.继承的细节
-
继承中的构造方法
在创建一个子类的对象同时也创建父类的对象 -
一个类可以
调用子类构造方法时,先会调用父类Animal的构造方法
5.总代码如下
- Animal是父类
public class Animal {
int x = 10;
static void y(){
System.out.println("aaaa");
}
/*
继承:父类和子类
子类会具有父类的一些功能,可以提高代码的重用性
继承是面向对象语言的一种设计思想,
提高代码的可重复利用性(儿子可以使用父亲)
代码的可扩展性(子类可以有自己的功能)
*/
/*
父类(基类)可以把一些共有的属性定义在父类中
当一个类没有写,会默认继承Object
Object是所有类的基类(父类)也叫超类
*/
private String name;
private int age;
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 void eat(){
System.out.println("动物吃");
}
public Animal(){
System.out.println("Animal的无参构造方法");
}
public Animal(String name){
this.name = name;
System.out.println(name);
}
static void f(){
System.out.println("大哥");
}
}
- Cat是Animal的子类
public class Cat extends Animal {
//子类可以扩展自己的功能
private String pinzhong;
public void setPinzhong(String pinzhong){
this.pinzhong = pinzhong;
}
public String getPinzhong(){
return pinzhong;
}
public void jiao() {
System.out.println("喵喵喵");
}
public Cat(){
super("哈哈");//如果supre里传入一个参数,则调用Animal中有参的构造方法
System.out.println("Cat的无参的构造方法");
}
}
- Tom是Cat的子类
public class Tom extends Cat{
public void feel(){
System.out.println("Tom会喂杰瑞吃饭");
}
public Tom(){
super();//如果要显示的调用,必须放在构造方法的第一行,先确保分类的调用
System.out.println("Tom类的无参构造方法");
super.eat();//可以通过super来调用父类中的方法
}
@Override
public void eat(){
System.out.println("Tom爱吃小鱼干");
}
}
- TomNext是测试类
public class TomNext {
/*继承中的构造方法
在创建一个子类的对象同时也创建父类的对象
*/
public static void main(String[] args) {
Tom tom = new Tom(); //这是相当于创建了Tom的对象,Cat的对象,Animal的对象,Object的对象
tom.eat();
}
}
二、关系
1.继承关系
- 一个类只能由一个直接父类
2.关联关系
- 关联关系:对象与对象直接的连接
- 表示有"has a" 什么什么 有 什么什么
public class People {
/*
表示有"has a" 什么什么 有 什么什么
*/
private String name;
private int age;
private Phone phone;//单项关联 一对一 人有一部电话
private Phone[] phones;//单项关联 一对多
private List Phoness;//
}
3.依赖关系
- 依赖关系"use a"
- 关联中某个方法使用到了另一个类
public class People {
/*
依赖关系"use a"
关联中某个方法使用到了另一个类
*/
public void feed(Cat cat){
cat.eat();
}
}
三、多态
1.什么是多态
- 多态:同一种事物,在不同时刻的不同的状态
- 多态的条件:
- 要有继承
- 要有方法重写
- 父类的引用 指向 子类对象
注
Animal tom = new Tom();//多态
DuoTai a = new DuoTai();//编译看左边,运行看右边
- 多态运行时,成员变量看左边
- 多态运行时,静态调用也看左边
2.多态的优点
- 在上述代码中我们在创建一个狗对象
- 重写父类里面的方法动物吃
public class Dog extends Animal {
int x = 10;
static void y(){
System.out.println("bbbbb");
}
@Override
public void eat(){
System.out.println("狗哥吃");
}
}
- 创建一个DouTai的类
- 下述是不用多态写的,要实现喂动物
- 那是不是要喂几个动物就要多写几个方法来调用
public class DuoTai {
public static void main(String[] args) {
Tom tom = new Tom();
DuoTai d = new DuoTai();
d.feed(tom);
}
public void feed(Tom tom){
tom.eat();
}
- 创建一个DouTai的类
- 只需要写一个方法运用多态来调用所有对象即可
public class DuoTai {
public static void main(String[] args) {
Animal tom = new Tom();//多态
DuoTai a = new DuoTai();//编译看左边,运行看右边
Animal dog = new Dog();
a.feed(tom);
a.feed( dog);
/*
多态运行时,成员变量看左边
多态运行时,静态调用也看左边
*/
System.out.println(dog.x);
dog.y();
}
public void feed(Animal animal){
animal.eat();
}
}