目录
- 继承概述、使用继承的好处
- 总结
- 继承的设计规范、内存运行原理
- 总结
- 继承的特点
- 总结
- 继承后：成员变量、成员方法的访问特点
- 总结
- 继承后：方法重写
- 继承后：子类构造器的特点
- 总结
- 继承后：子类构造器访问父类有参构造器
- 总结
- this、super使用总结
继承概述、使用继承的好处
package com.zixin.d5_extends;
public class People {
public void run(){
System.out.println("人会跑~~");
}
}
package com.zixin.d5_extends;
public class Student extends People{
}
package com.zixin.d5_extends;
public class Test {
public static void main(String[] args) {
Student s =new Student();
s.run();
}
}
总结
1．什么是继承?继承的好处是啥?
- 继承就是java允许我们用extends关键字，让一个类和另一个类建立起一种父子关系。
- 提高代码复用性，减少代码冗余，增强类的功能扩展性。
2．继承的格式
- 子类 extends 父类
3．继承后子类的特点?
- 子类继承父类，子类可以得到父类的属性和行为，子类可以使用。Java中子类更强大
继承的设计规范、内存运行原理
package com.zixin.d6_extends_test;
public class People {
private String name;
private int age;
public void queryCourse(){
System.out.println(name + "再查看课表~~");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package com.zixin.d6_extends_test;
public class Student extends People {
public void writeInfo(){
System.out.println(getName()+"写下了：学习语法，好开心~~");
}
}
package com.zixin.d6_extends_test;
public class Test {
public static void main(String[] args) {
Student s =new Student();
s.setName("嘻哈");
s.setAge(999);
System.out.println(s.getName());
System.out.println(s.getAge());
s.queryCourse();
s.writeInfo();
}
}
总结
1．继承需要满足什么样的设计规范?
- 子类们相同特征（共性属性，共性方法）放在父类中定义。
- 子类独有的的属性和行为应该定义在子类自己里面。
继承的特点
package com.zixin.d7_extends_feature;
public class Test {
public static void main(String[] args) {
Tiger t = new Tiger();
// t.eat();
}
}
class Animal{
private void eat(){
System.out.println("动物要吃东西~");
}
}
class Tiger extends Animal{
}
package com.zixin.d7_extends_feature;
public class Test {
public static void main(String[] args) {
Tiger t = new Tiger();
// t.eat();
System.out.println(Tiger.location);
}
}
class Animal{
private void eat(){
System.out.println("动物要吃东西~");
}
public static String location = "长隆动物园";
}
class Tiger extends Animal{
}
总结
1．继承有哪些特点?
子类可以继承父类的属性和行为，但是子类不能继承父类的构造器。
Java是单继承模式:一个类只能继承一个直接父类。
Java不支持多继承、但是支持多层继承。
Java中所有的类都是Object类的子类。
继承后：成员变量、成员方法的访问特点
package com.zixin;
public class d8_extends_field_method {
public static void main(String[] args) {
Dog d =new Dog();
d.run();
d.lookDoor();
d.showName();
}
}
class Animal{
public String name = "动物名";
public void run(){
System.out.println("动物可以跑~");
}
}
class Dog extends Animal{
public String name="狗名";
public void lookDoor(){
System.out.println("狗可以看门");
}
public void showName(){
// String name ="局部名";
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
super.run();
run();
}
public void run(){
System.out.println("狗跑的贼快~");
}
}
总结
继承后：方法重写
package com.zixin.d9_extends_override;
public class Test {
public static void main(String[] args) {
NewPhone iphone = new NewPhone();
iphone.call();
iphone.sendMsg();
}
}
class NewPhone extends Phone{
@Override
public void call(){
super.call();
System.out.println("开始视频童话");
}
@Override
public void sendMsg(){
super.sendMsg();
System.out.println("发送有趣的图片~");
}
}
class Phone{
public void call(){
System.out.println("打电话~");
}
public void sendMsg(){
System.out.println("发短信~");
}
}
继承后：子类构造器的特点
package com.zixin.d10_extends_constructor;
public class Animal {
public Animal(){
System.out.println("父类Animal无参构造器被执行");
}
}
package com.zixin.d10_extends_constructor;
public class Dog {
public Dog(){
System.out.println("子类Dog无参数构造器被执行~");
}
public Dog(String name){
System.out.println("子类Dog有参数构造器被执行");
}
}
package com.zixin.d10_extends_constructor;
public class Test {
public static void main(String[] args) {
Dog d1 = new Dog();
System.out.println(d1);
System.out.println("-------");
Dog d2 = new Dog("土狗");
System.out.println(d2);
}
}
总结
1．子类继承父类后构造器的特点是什么样的?
子类中所有的构造器默认都会先访问父类中无参的构造器，再执行自己。
继承后：子类构造器访问父类有参构造器
package com.zixin.d11_extends_constructor;
public class People {
private String name;
private int age;
public People() {
}
public People(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package com.zixin.d11_extends_constructor;
public class Teacher extends People{
public Teacher(){
}
public Teacher(String name , int age){
super(name,age);
}
}
package com.zixin.d11_extends_constructor;
public class Test {
public static void main(String[] args) {
Teacher t = new Teacher("王阳明",14);
System.out.println(t.getAge());
System.out.println(t.getName());
}
}
总结
1、super调用父类构造器的作用是什么?
通过调用父类有参数构造器来初始化继承自父类的数据
this、super使用总结
package com.zixin.d12_this;
public class Student {
private String name;
private String schoolName;
public Student(){
}
public Student(String name){
this(name,"之见者");
}
public Student(String name, String schoolName) {
this.name = name;
this.schoolName = schoolName;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSchoolName() {
return schoolName;
}
public void setSchoolName(String schoolName) {
this.schoolName = schoolName;
}
}
package com.zixin.d12_this;
public class Test {
public static void main(String[] args) {
Student s1 =new Student("许青","七血瞳");
System.out.println(s1.getName());
System.out.println(s1.getSchoolName());
Student s2 = new Student("张三丰");
System.out.println(s2.getName());
System.out.println(s2.getSchoolName());
}
}
