文章目录
- 1. 为什么需要继承
- 2. 继承基本介绍和示意图
- 3. 继承的基本语法
- 4. 快速入门案例
- 5. 继承给编程带来的便利
- 6. 继承的深入讨论/细节问题
- 7. 继承的本质分析(重要)
- 8. 练习
1. 为什么需要继承
- 一个小问题,还是看个程序[
com.xdr630.extend_包: Extends01.java],提出代码复用的问题。 - 编写了两个类，一个是
Pupil类(小学生)，一个是Graduate(大学毕业生).
package com.xdr630.extends_;
public class Pupil {
public String name;
public int age;
private double score;
public void setScore(double score) {
this.score = score;
}
public void testing(){
System.out.println("小学生 " + name + " 正在考小学数学..");
}
public void showInfo(){
System.out.println("学生名 " + name + " 年龄" + age + " 成绩" + score);
}
}
package com.xdr630.extends_;
public class Graduate {
public String name;
public int age;
private double score;
public void setScore(double score) {
this.score = score;
}
public void testing(){
System.out.println("大学生 " + name + " 正在考大学数学..");
}
public void showInfo(){
System.out.println("学生名 " + name + " 年龄" + age + " 成绩" + score);
}
}
package com.xdr630.extends_;
public class Extends01 {
public static void main(String[] args) {
Pupil pupil = new Pupil();
pupil.name = "小明";
pupil.age = 10;
pupil.setScore(60);
pupil.showInfo();
System.out.println("=====================");
Graduate graduate = new Graduate();
graduate.name = "大明";
graduate.age = 23;
graduate.setScore(100);
graduate.showInfo();
}
}
- 问题:两个类的属性和方法有很多是相同的，怎么办?
=>继承(代码复用性~)
2. 继承基本介绍和示意图
- 继承可以解决代码复用,让我们的编程更加靠近人类思维.当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类,在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过
extends 来声明继承父类即可。 - 继承的示意图
3. 继承的基本语法
4. 快速入门案例
- 对
Extends01.java 改进，使用继承的方法,请注意体会使用继承的好处
package com.xdr630.extends_.improve_;
// 父类，是 Pupil 和 Graduate 的父类
public class Student {
//共有属性
public String name;
public int age;
private double score;
//共有方法
public void setScore(double score) {
this.score = score;
}
}
package com.xdr630.extends_.improve_;
public class Pupil extends Student{
public void testing(){
System.out.println("小学生 " + name + " 正在考小学数学..");
}
}
package com.xdr630.extends_.improve_;
public class Graduate extends Student{
public void testing(){
System.out.println("大学生 " + name + " 正在考大学数学..");
}
}
package com.xdr630.extends_.improve_;
import com.xdr630.extends_.Graduate;
import com.xdr630.extends_.Pupil;
public class Extends01 {
public static void main(String[] args) {
com.xdr630.extends_.Pupil pupil = new Pupil();
pupil.name = "小明";
pupil.age = 10;
pupil.setScore(60);
pupil.showInfo();
System.out.println("=====================");
com.xdr630.extends_.Graduate graduate = new Graduate();
graduate.name = "大明";
graduate.age = 23;
graduate.setScore(100);
graduate.showInfo();
}
}
5. 继承给编程带来的便利
- 代码的复用性提高了
- 代码的扩展性和维护性提高了
6. 继承的深入讨论/细节问题
- 子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问, 但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问。
- Base 父类
package com.xdr630.extends_;
public class Base { //父类
//4个属性
public int n1 = 100;
protected int n2 = 200;
int n3 = 300;
private int n4 = 400;
//父类提供一个public方法，返回了n4
public int getN4() {
return n4;
}
public Base(){
System.out.println("Base()....");
}
public void test100() {
System.out.println("test100");
}
protected void test200() {
System.out.println("test200");
}
void test300() {
System.out.println("test300");
}
private void test400() {
System.out.println("test400");
}
public void callTest400(){
test400();
}
}
- Sub 子类
package com.xdr630.extends_;
//输入ctrl + H 可以看到类的继承关系
public class Sub extends Base { //子类
public Sub() {//无参构造器
System.out.println("子类Sub()构造器被调用....");
}
public void sayOk() {//子类方法
//非私有的属性和方法可以在子类直接访问
//但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问
System.out.println(n1 + " " + n2 + " " + n3);
test100();
test200();
test300();
//通过父类提供公共的方法去访问
System.out.println("n4=" + getN4());
//通过父类提供公共的方法去访问
callTest400();
}
}
- ExtendsDetail 测试类
package com.xdr630.extends_;
public class ExtendsDetail {
public static void main(String[] args) {
Sub sub = new Sub();
sub.sayOk();
}
}
- 子类必须调用父类的构造器， 完成父类的初始化
public class Base { //父类
public Base(){
System.out.println("父类Base()构造器被调用....");
}
}public class Sub extends Base { //子类
public Sub() {//无参构造器
//默认调用父类的无参构造方法
//super();
System.out.println("子类Sub()构造器被调用....");
}
}public class ExtendsDetail {
public static void main(String[] args) {
Sub sub = new Sub();
}
}
- 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用
super 去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过。
- 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器
public class Base { //父类
public Base(){
System.out.println("父类Base()构造器被调用....");
}
}public class Sub extends Base { //子类
public Sub() {
System.out.println("子类Sub()构造器被调用....");
}
public Sub(String name){
System.out.println("子类Sub(String name)构造器被调用....");
}
}public class ExtendsDetail {
public static void main(String[] args) {
Sub sub = new Sub();
System.out.println("===第二个对象===");
Sub sub2 = new Sub("jack");
}
}
- 如果父类没有提供无参构造器，则必须在子类的构造器中用
super 去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过。
public class Base { //父类
public Base(String name,int age){//有参构造器
System.out.println("父类Base(String name,int age)构造器被调用....");
}
}public class Sub extends Base { //子类
public Sub(String name){
super("tom",30);
System.out.println("子类Sub(String name)构造器被调用....");
}
}public class ExtendsDetail {
public static void main(String[] args) {
System.out.println("===第一个对象===");
Sub sub = new Sub();
System.out.println("===第二个对象===");
Sub sub2 = new Sub("jack");
}
}
- 如果希望指定去调用父类的某个构造器，则显式的调用一下 :
super(参数列表)
public class Base { //父类
public Base(String name,int age){//有参构造器
System.out.println("父类Base(String name,int age)构造器被调用....");
}
}public class Sub extends Base { //子类
public Sub(String name){
super("tom",30);
System.out.println("子类Sub(String name)构造器被调用....");
}
}public class ExtendsDetail {
public static void main(String[] args) {
System.out.println("===第三个对象===");
Sub sub3 = new Sub("mike");
}
}
super 在使用时，必须放在构造器第一行(super 只能在构造器中使用)
super() 和 this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器
java 所有类都是 Object 类的子类, Object 是所有类的基类.
父类构造器的调用不限于直接父类，将一直往上追溯直到 Object 类(顶级父类)
子类最多只能继承一个父类(指直接继承)，即 java 中是单继承机制。
思考：如何让 A 类继承 B 类和 C 类？ 【A 继承 B， B 继承 C】
不能滥用继承，子类和父类之间必须满足 is-a 的逻辑关系
7. 继承的本质分析(重要)
- 看一个案例来分析当子类继承父类，创建子类对象时，内存中到底发生了什么? 提示:当子类对象创建好后，建立查找的关系。
public class ExtendsTheory {
public static void main(String[] args) {
Son son = new Son();//内存的布局
//-> 这时请大家注意，要按照查找关系来返回信息
//(1) 首先看子类是否有该属性
//(2) 如果子类有这个属性，并且可以访问，则返回信息
//(3) 如果子类没有这个属性，就看父类有没有这个属性(如果父类有该属性，并且可以访问，就返回信息..)
//(4) 如果父类没有就按照(3)的规则，继续找上级父类，直到Object...
System.out.println(son.name);//返回就是大头儿子
System.out.println(son.getAge());//返回的就是39
System.out.println(son.hobby);//返回的就是旅游
}
}
class GrandPa { //爷类
String name = "大头爷爷";
String hobby = "旅游";
}
class Father extends GrandPa {//父类
String name = "大头爸爸";
private int age = 39;
public int getAge() {
return age;
}
}
class Son extends Father { //子类
String name = "大头儿子";
}
- 子类创建的内存布局
8. 练习
- 案例 1
ExtendsExercise01.java
public class ExtendsExercise01 {
public static void main(String[] args) {
B b = new B();//a , b name, b
}
}
class A {
A() {
System.out.println("a");
}
A(String name) {
System.out.println("a name");
}
}
class B extends A {
B() {
this("abc");
System.out.println("b");
}
B(String name) {
//默认有 super();
System.out.println("b name");
}
}- main中：
B b = new B(); 会输出什么?
- 案例 2
ExtendsExercise02.java
public class ExtendsExercise02 {
public static void main(String[] args) {
C c = new C();
}
}
class A {//A类
public A() {
System.out.println("我是A类");
}
}
class B extends A { //B类,继承A类
public B() {
System.out.println("我是B类的无参构造");
}
public B(String name) {
System.out.println(name + "我是B类的有参构造");
}
}
class C extends B { //C类，继承 B类
public C() {
this("hello");
System.out.println("我是c类的无参构造");
}
public C(String name) {
super("hahah");
System.out.println("我是c类的有参构造");
}
}- main方法中：
C c = new C(); 输出么内容?
- 案例 3
ExtendsExercise03.java
- 编写 Computer 类，包含 CPU、内存、硬盘等属性，getDetails 方法用于返回 Computer 的详细信息
- 编写 PC 子类，继承 Computer 类，添加特有属性【品牌 brand】
- 编写 NotePad 子类，继承 Computer 类，添加特有属性【color】
- 编写 Test 类，在 main 方法中创建 PC 和 NotePad 对象，分别给对象中特有的属性赋值，以及从 Computer 类继承的属性赋值，并使用方法并打印输出信息
public class Computer {
private String cpu;
private int memory;
private int disk;
public Computer(String cpu, int memory, int disk) {
this.cpu = cpu;
this.memory = memory;
this.disk = disk;
}
//返回Computer信息
public String getDetails() {
return "cpu=" + cpu + " memory=" + memory + " disk=" + disk;
}
public String getCpu() {
return cpu;
}
public void setCpu(String cpu) {
this.cpu = cpu;
}
public int getMemory() {
return memory;
}
public void setMemory(int memory) {
this.memory = memory;
}
public int getDisk() {
return disk;
}
public void setDisk(int disk) {
this.disk = disk;
}
}public class PC extends Computer{
private String brand;
public PC(String cpu, int memory, int disk, String brand) {
super(cpu, memory, disk);
this.brand = brand;
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public void printInfo() {
System.out.println("PC信息=");
System.out.println(getDetails() + " brand=" + brand);
}
}public class ExtendsExercise03 {
public static void main(String[] args) {
PC pc = new PC("intel", 16, 500, "IBM");
pc.printInfo();
}
}
