1. 继承接上 2. 继承的好处 1) 代码的复用性提高了 2) 代码的扩展性和维护性提高了 3. 继承的深入讨论及细节288 1) 子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访
1. 继承接上
2. 继承的好处
1) 代码的复用性提高了
2) 代码的扩展性和维护性提高了
3. 继承的深入讨论及细节288
1) 子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问, 但是私有属性和方法不能在子类直接访 问，要通过父类提供公共的方法去访问 288
2) 子类必须调用父类的构造器， 完成父类的初始化 289
3) 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无 参构造器，则必须在子类的构造器中用 super 去指定使用父类的哪 个构造器完成对父类的初始化工作，否则，编译 不会通过(怎么理解。) [举例说明] 289
4) 如果希望指定去调用父类的某个构造器，则显式的调用一下 : super(参数列表) 290
5) super 在使用时，必须放在构造器第一行(super 只能在构造器中使用) 290
6) super() 和 this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器 290
7) java 所有类都是 Object 类的子类, Object 是所有类的基类. 291
8) 父类构造器的调用不限于直接父类！将一直往上追溯直到 Object 类(顶级父类) 291
9) 子类最多只能继承一个父类(指直接继承)，即 java 中是单继承机制。 思考：如何让 A 类继承 B 类和 C 类？ 【A 继承 B， B 继承 C】 292
10) 不能滥用继承，子类和父类之间必须满足 is-a 的逻辑关系 292
3.1 细节举例，由于内容众多参考视频讲解
代码在com.stulzl.extend_.包中
测试ExtendsDetail
package com.stulzl.extend_;
public class ExtendsDetail { //288
public static void main(String[] args) {
// Sub sub = new Sub(); //288
// //sub.sayOk();
//
// System.out.println("=========="); //289
// Sub sub2 = new Sub("jack");
System.out.println("=========="); //290
Sub sub3 = new Sub("jack",13);
}
}父类Base
package com.stulzl.extend_;
public class Base { //父类
//4个属性
public int n1 = 100;
protected int n2 = 200;
int n3 = 300;
private int n4 = 400;
//无参构造器
public Base() {
System.out.println("父类Base()构造器被调用....");
}
//有参构造器1
public Base(String name, int age) {
//默认super()
System.out.println("父类Base(String name, int age)构造器被调用....");
}
//有参构造器2
public Base(String name) {
System.out.println("父类Base(String name)构造器被调用....");
}
//父类提供一个公共的getN4方法,返回了n4
public int getN4() {
return n4;
}
//4 个方法
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");
}
//提供一个公共callTest40方法调用test400
public void callTest400() {
test400();
}
}子类Sub
package com.stulzl.extend_;
//输入Ctrl+H可以看到类的继承关系
public class Sub extends Base//子类
{
//如果希望指定去调用父类的某个构造器，则显式的调用一下 : super(参数列表) 290
public Sub(String name,int age){
//1.我们先调用父类无参构造器
//super(); //super 在使用时，必须放在构造器第一行
//2. 我们调用父类的有参构造器2 Base(String name)
super("lzl");
System.out.println("子类Sub(String name,int age)构造器被调用……");
}
public Sub() {//无参构造器
//子类必须调用父类的构造器，完成父类的初始化
//super();//此句被隐藏，作用是默认调用父类无参构造器
//如果父类没有提供无 参构造器，则必须在子类的构造器中用 super 去指定使用父类的哪
// 个构造器完成对父类的初始化工作，否则，编译 不会通过
super("smith",10);//此句特别指定父类构造器
System.out.println("子类sub()构造器被调用……");
}
//当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器 289
public Sub(String name){
super("tom",30);//此句特别指定父类构造器
System.out.println("子类Sub(String name)构造器被调用……");
}
// 子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问,
// 但是私有属性和方法不能在子类直接访 问，要通过父类提供公共的方法去访问
public void sayOk()//子类方法
{
//非私有的属性和方法可以在子类直接访问,即n4不能直接访问
//但是私有属性和方法不能在子类直接访
System.out.println(n1+" "+n2+" "+n3+" ");
test100();
test200();
test300();
//test400();不能直接访问
//要通过父类提供公共的方法去访问
System.out.println("n4="+getN4());
callTest400();
}
}4. 继承的本质分析 293
4.1 案例 293
访问规则
//1. 先看子类是否有该属性并且可以访问，则返回信息
//2. 如果子类没有，则看父类(如果父类有该属性，且可以访问，则返回信息)
//3. 如果父类没有，就重复按照2.的规则继续向上级父类，直到Object
代码在com.stulzl.extendstheory_.包中
ExtendsTheory
import sun.security.jgss.GSSUtil;
//继承的本质分析
public class ExtendsTheory {
public static void main(String[] args) {
Son son = new Son();
//输出谁的名字呢，要按照查找关系来返回信息
//1. 先看子类是否有该属性并且可以访问，则返回信息
//2. 如果子类没有，则看父类(如果父类有该属性，且可以访问，则返回信息(如果有但不可以访问，就报错))
//3. 如果父类没有，就重复按照2.的规则继续向上级父类，直到Object
System.out.println(son.name);//大头儿子
System.out.println(son.age);//39
//System.out.println(son.getAge());//40
System.out.println(son.hobby);//旅游
}
}
class Grandpa{//爷类
String name="大头爷爷";
String hobby="旅游";
}
class Father extends Grandpa{//父类
String name="大头爸爸";
int age = 39;
// private int age = 40;
// public int getAge(){
// return age;
// }
}
class Son extends Father{//子类
String name="大头儿子";
}5.继承练习
5.1 判断输出 294
代码在com.stulzl.extends_exercise.包中
ExtendsExercise01
package com.stulzl.extends_exercise;
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语句，所以此语句就不会有默认的super了
this("abc");//执行调用B(String name)构造器之前,会默认的调用A类的无参构造器，然后在执行B有参，后A无参
System.out.println("b");
}
B(String name){//有参的构造器
System.out.println("b name");
}
}
5.2 判断输出 295
代码在com.stulzl.extends_exercise.包中
ExtendsExercise01
//判断输出2 295
public class ExtendsExercise01 {
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 类 //main 方法中： C c =new C(); 输出么内容? 3min
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 类的有参构造");
}
}
5.3 编程题 296
编写 Computer 类，包含 CPU、内存、硬盘等属性，getDetails 方法用于返回 Computer 的详细信息
编写 PC 子类，继承 Computer 类，添加特有属性【品牌 brand】
编写 NotePad 子类，继承 Computer 类，添加特有属性【color】
编写 Test 类，在 main 方法中创建 PC 和 NotePad 对象，分别给对象中特有的属性赋值，以及从 Computer 类继承的 属性赋值，并使用方法并打印输出信息
代码在com.stulzl.extends_exercise3.包中
测试ExtendsExercise03
package com.stulzl.extends_exercise3;
//编写 Computer 类，包含 CPU、内存、硬盘等属性，getDetails 方法用于返回 Computer 的详细信息
//编写 PC 子类，继承 Computer 类，添加特有属性【品牌 brand】
//编写 NotePad 子类，继承 Computer 类，添加特有属性【color】
//编写 ExtendsExercise03 类，在 main 方法中创建 PC 和 NotePad 对象，分别给对象中特有的属性赋值，
// 以及从 Computer 类继承的 属性赋值，并使用方法并打印输出信息
public class ExtendsExercise03 {
public static void main(String[] args) {
PC pc = new PC("intel", 16, 512, "IBM");
pc.printInfo();
Notepad notepad = new Notepad("黑色");
notepad.printInfo2();
}
}父类Computer
package com.stulzl.extends_exercise3;
//编写 Computer 类，包含 CPU、内存、硬盘等属性，getDetails 方法用于返回 Computer 的详细信息
public class Computer { //父类
private String cpu;
private int memory;
private int disk;
//无参构造器
public Computer() {
}
//构造器
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;
}
}子类PC
package com.stulzl.extends_exercise3;
//编写 PC 子类，继承 Computer 类，添加特有属性【品牌 brand】
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的信息如下");
//调用父类的 getDetails 方法，得到相关属性信息
System.out.println(getDetails()+" brand="+brand);
}
}子类Notepad
package com.stulzl.extends_exercise3;
public class Notepad extends Computer {
private String color;
//构造器
public Notepad(String color) {
super();
this.color = color;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
//输出信息
public void printInfo2(){
System.out.println("color="+color);
}
}