java 第四章面向对象（下）继承和多态

最新推荐文章于 2022-09-20 23:55:19 发布

与君随

最新推荐文章于 2022-09-20 23:55:19 发布

阅读量488

点赞数

本文链接：https://blog.csdn.net/weixin_52138829/article/details/117423185

版权

本文详细探讨了Java中的面向对象特性，包括继承的原则与特点，如单一继承、构造方法的访问，以及super和this关键字的使用。文章还介绍了抽象类和接口，强调了抽象方法的覆盖重写规则，以及接口的默认方法、静态方法和私有方法。多态的概念也被解释，讨论了成员变量和成员方法的访问规则以及对象转型。最后，文中提及了异常处理的基本概念，包括try-catch和throw关键字的应用。

摘要由CSDN通过智能技术生成

继承和多态

继承

继承设计原则:对于已经投入使用的类，尽量不要进行修改。
推荐定义一个新的类，来重复利用其中共性内容，并且添加改动新内容。

理解：
继承是多态的前提，如果没有继承，就没有多态。
类比：师父会多少武功，大徒弟也都会，小徒弟也都会。
继承主要解决的问题就是:共性抽取。
父类也可以叫基类、超类
子类也可以叫派生类
继承关系当中的特点:
1.子类可以拥有父类的“内容”
2.以拥有自己专有的内容。
特点：
Java语言是单继承的。一个类的直接父类只能有唯一一个。
class A {}
class B extends A {}//正确
class C{}
class D extends A,C{}//错误
Java语言可以多级继承。
我有一个父亲，我父亲还有一个父亲，也就是爷爷。

因为：
在这里插入图片描述

格式：
在继承的关系中，“子类就是一个父类”。也就是说，子类可以被当做父类看待。

定义父类的格式:(一个普通的类定义)
public class父类名称{
/ / …
}
定义子类的格式:
public cLass 子类名称 extends 父类名称{
//…
}
子类可以调用父类的方法即使子类方法中什么也不写

代码：

//定义一个父类:员工
public class Employee {
   
	public void method() {
   
	System.out.println("方法执行!");
	}
}

//定义了一个员工的子类:讲师
public class Teacher extends Employee {
   
	
}

public class Demoo1Extends {
   
	public static void main(String[] args) {
   
		//创建了一个子类对象
		Teacher teacher = new Teacher();
		//Teacher类当中虽然什么都没写，但是会继承来自父类的method方法。
		teacher.method();
	}
}

继承中成员变量的访问特点

在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式:
直接通过子类对象访问成员变量:
规则：等号左边是谁，就优先用谁,没有则向上找。

 Zi zi = new Zi();
 	 System.out.println(zi.num);

间接通过成员方法访问成员变量:
该方法属于准，就优先用谁,没有则向上找。

public class Zi extends Fu {
   
	int numZi = 20;
	int num = 200;
	public void methodzi() {
   
		//因为本类当中有num,所以这里用的是本类的num，而不是父类的num
		System.out.println(num);
	}
}

区分子类方法中重名的三种变量

局部变量: 直接写成员变量名
本类的成员变量: this.成员变量名
父类的成员变量: super.成员变量名
在父子类的继承关系当中，创建子类对象，访问重名成员方法的规则:
创建的对象是谁（看new的是谁）,就优先用谁，如果没有则向上找。

new三重名
public class Zi extends Fu {
   
	int num = 20;
	public void method() {
   
	int num = 30;
	System.out.println(num); // 30，局部变量
	System.out.println(this.num); // 20，本类的成员变量
	System.out.println(super.num);// 10，父类的成员变量
	}
}

继承中方法的覆盖重写

重写( Override)
概念:在继承关系当中，方法的名称一样，参数列表也一样。
重写(Override):方法的名称一样，参数列表【也一样】。覆盖、覆写。
重载（OverLoad):方法的名称一样，参数列表【不一样】。
方法覆盖重写的注意事项;
1．必须保证父子类之间方法的名称相同，参数列表也相同。
@Override:写在方法前面，用来检测是不是有效的正确覆盖重写。这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。
2．子类方法的返回值必须【小于等于】父类方法的返回值范围。
小扩展提示。java.Lang.object类是所有类的公共最高父类（祖宗类），java.Lang. string就是object的子类。
3．子类方法的权限必须【大于等于】父类方法的权限修饰符。
小扩展提示:public > protected > (default) > private
备注:(default)不是关键字default，而是什么都不写，留空。

//定义一个新手机，使用老手机作为父类
public class NewPhone extends Phone {
   
	//@Override
	public void show() {
   
		super.show(); //把父类的show方法拿过来重复利用
		//自己子类再来添加更多内容
		System.out.println("显示姓名");
		System.out.println("显示头像");
	}
}

构造方法的访问特点

继承关系中，父子类构造方法的访问特点:
1．子类构造方法当中有一个默认隐含的“super()"调用，所以一定是先调用的父类构造，后执行的子类构造。

package cn.itcast.day09.demo07 ;
public class Fu {
   
	public Fu() {
   
		System.out.println("父类构造方法!");
	}
}
package cn.itcast.day09.demo07;
public class Zi extends Fu {
   
	public Zi() {
   
		super(); //在调用父类无参构造方法,不写也照样有
		System.out.println("子类构造方法!");
	}
}
先输出父类构造

2.子类构造可以通过super关键字来调用父类重载构造。

public class Fu {
   
	public Fu() {
   
		System.out.println("父类无参构造");
	}
	public Fu(int num) {
   
		System.out.println("父类构造方法!");
	}
}
public class Zi extends Fu {
   
	public Zi() {
   
		//super(); //在调用父类无参构造方法
		super(20);//在调用父类重载的构造方法
		System.out.println("子类构造方法!");
	}
}

3.super的父类构造调用，必须是子类构造方法的第一个语句。不能在一个子类写两个super

super(); //在调用父类无参构造方法
super(20);//在调用父类重载的构造方法

总结:
子类必须调用父类构造方法，不写则赠送super();写了则用写的指定的super调用，super只能有一个，还必须是第一个。

super关键字

super关键字的用法有三种:
1．在子类的成员方法中，访问父类的成员变量。
2．在子类的成员方法中，访问父类的成员方法。
3．在子类的构造方法中，访问父类的构造方法。

public class Zi extends Fu {
   
	int num = 20;
	public Zi(){
   
		super();
	}
	public void methodZi() {
   
		System.out.println(super.num); //父类中的num
	}
	public void method() {
   
		super.method(); //访问父类中的method
		System.out.println("子类方法");
	}
}

this关键字

super关键字用来访问父类内容，而this关键字用来访间本类内容。用法也有三种:
1．在本类的成员方法中,访问本类的成员变量。
2．在本类的成员方法中，访问本类的另—个成员方法。
3．在本类的构造方法中，访问本类的另一个构造方法(注意：this(…)调用也必须是构造方法的第一个语句,也不能写多个。super和this两种构造调用，不能同时使用)。

public Zi() {
   
	//super(); //这一行不再赠送，赠送的话this就不是第一个了
	this(123); //本类的无参构造，调用本类的有参构造
	//this(1,2); //错误写法!不能同时写两个this调用
	}
	public Zi(int n) {
   
		
	}
	public Zi(int n, int m) {
   
		
	}
}
public class Zi extends Fu {
   
	int num = 20;
	public void showNum( ) {
   
		int num = 10;
		System.out.println(num); //局部变量
		System.out.print1n(this.num);//本类中的成员变量
		System.out.println(super.num); //父类中的成员变量
	}
	public void methodA( ) {
   
		System.out.println("AAA");
	}
	public void methodB() {
   
		this.methodA();
		System.out.println("BBB");
	}
}

抽象

一个动物肯定可以吃东西，但是吃什么东西不一定
在这里插入图片描述

抽象方法和抽象类

抽象方法:就是加上abstract关键字，然后去掉大括号，直接分号结束。
抽象类:抽象方法所在的类，必须是抽象类才行。在cLass之前写上abstract即可。抽象类是__不能实例化的类____。

如何使用抽象类和抽象方法:

不能直接创建new抽象类对象。
必须用一个子类来继承抽象父类。
子类必须覆盖重写抽象父类当中所有的抽象方法。
覆盖重写（实现)∶子类去掉抽象方法的abstract关键字，然后补上方法体大括号。
创建子类对象进行使用。

public abstract class Animal {
   
//这是一个抽象方法，代表吃东西，但是具体吃什么(大括号的内容）不确定。
	public abstract void eat();
}
public class Cat extends Animal {
   
	public void eat() {
   
		System.out.print1n("猫吃鱼");
	}
}
public class MyClass {
   
	public static void main(String[] args) {
   
		Cat cat=new Cat();
		cat.eat();
	}
}
输出：猫吃鱼

例题：

public class Demo {
   
    public static void main(String[] args) {
   
        Demo demo = new Demo();
        demo.show(new Car() {
   
            public void run() {
   
                System.out.println("demo run");
            }
        });
    }
    public void show(Car c) {
   
        c.run();
    }
}
abstract class Car {
   
    public void run() {
   
        System.out.println("car run...");
    }
}
输出：
demo run

注意事项：
关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。

1.抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

理解:假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

2.抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

理解:子类的构造方法中，有默认的super()，首先会访问父类构造方法。

3.抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

理解:未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。
这样没有抽象方法的抽象类，也不能直接创建对象，在一些特殊场景下有用途。
public abstract class MyAbstract {
}

4.抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。

理解:假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

接口

生活中的接口举例：电源插座当中的电源接口
接口就是一种公共的规范标准。
只要符合规范标准，就可以大家通用。
例如：只要符合USB接口的规范,那么各种设备都可以使用:
U盘、打印机、夜读灯、USB小风扇…

接口就是多个类的公共

最低0.47元/天解锁文章

与君随

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
java 第四章面向对象（下）继承和多态

继承和多态继承继承中成员变量的访问特点区分子类方法中重名的三种变量继承中成员方法的访问特点继承中方法的覆盖重写构造方法的访问特点super关键字this关键字抽象抽象方法和抽象类接口接口的抽象方法接口的默认方法接口的静态方法接口的私有方法继承父类和多个接口接口间的多继承多态成员变量和成员方法对象的转型instanceof关键字final关键字内部类局部内部类匿名内部类类作为成员变量接口作为成员变量和方法参数继承理解：继承是多态的前提，如果没有继承，就没有多态。类比：师父会多少武功，大徒弟也都会，小徒
复制链接

扫一扫