EXCEL基本应用之新建EXCEL的两种方式及打开EXCEL的三种常用方法(新建excel表格有几种方法)
442
2022-05-29
1. 为什么需要继承
2. 继承基本介绍和示意图
3. 继承的基本语法
4. 快速入门案例
5. 继承给编程带来的便利
6. 继承的深入讨论/细节问题
7. 继承的本质分析(重要)
8. 练习
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(); } }
Java
版权声明:本文内容由网络用户投稿,版权归原作者所有,本站不拥有其著作权,亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容,请联系我们jiasou666@gmail.com 处理,核实后本网站将在24小时内删除侵权内容。