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);
}
}
