Java进阶总结——继承

超、凢脫俗 2022-05-18 03:15 209阅读 0赞

**Java进阶总结4**

1.继承

1.1继承的定义

/\*\*

\* 子类继承父类

\* 可以继承父类公共属性和方法 如果是私有的不能继承

\* 继承需要关键字 extends

\* java只支持单继承（只有一个亲父亲）

\* 子类可以拥有自己的特性

\* \*/

1.2super

/\*\*

\* 子类

\* super 可以访问父类的属性和方法

\* super 只能存在在子类的方法中

\* super 可以存在子类的构造方法中 用来调用父类的构造方法 必须放在构造方法的第一行Super();

\* \*/

package day09;

/\*

\* 父类

\* 存放子类公共的属性

\* \*/

public class Person \{

//公共属性

String name;

int age;

private int tel;//电话

protected String address;

public  Person() \{

System.out.println("父类默认构造方法");

public  Person(String name) \{

this();

System.out.println("父类中带参数的构造方法");

//方法

public void sleep() \{

System.out.println(name+"\\t\\t"+age+"\\t\\t睡觉");

package day09;

public class Employee extends Person\{

//属性

String hirDete;//入职时间

//子类中定义和父类相同的属性和方法

String name;

public void sleep() \{

System.out.println("不能睡了");

//子类的构造方法

/\*\*

\* 初始化一个对象的时候 ，构造方法必须调用一次

\* 1.如果子类的构造方法没有显示调用父类的构造方法，会默认执行默认的构造方法

\* 2.如果显示（super）调用父类指定的构造方法，父类指定的构造方法会被执行一次

\* \*/

public  Employee() \{

//显示调用父类构造方法

//super();//指定调用默认的构造方法

super("尊");//指定调用带参数的构造方法

System.out.println("子类默认的构造方法");

public  Employee(String name) \{

System.out.println("子类有参构造方法");

//行为

public void method1() \{

//不使用super可以访问父类的成员

//子类和父类没有相同的属性和方法

System.out.println("name=="+this.name);//调用当前类

System.out.println("super name=="+super.name);//调用父类

super.sleep();

this.sleep();

package day09;

public class Student extends Person\{

//属性

String sid;//学号

package day09;

/\*\*

\* 子类

\* \*/

public class Teacher extends Person\{

//属性

int level;//级别

package day09;

//测试类

public class TestDemo \{

public static void main(String\[\] args) \{

// TODO 自动生成的方法存根

//初始化一个Student对象 给对象赋值

Student stu=new Student();

stu.sid="001";

stu.name="熊大";

stu.age=22;

//stu.tel=112233;//父类的私有成员不能被访问

stu.sleep();

System.out.println(stu.sid);

//初始化一个Teacher对象 给对象赋值

Teacher tea=new Teacher();

tea.name="熊二";

tea.age=21;

tea.level=3;

tea.sleep();

System.out.println(tea.level);

//初始化一个Employeer对象 给对象赋值

Employee em=new Employee();

em.name="熊三";

em.age=19;

em.hirDete="2018";

em.sleep();

em.method1();

System.out.println(em.hirDete);

输出结果：

![70][]

1.3测试继承范围

package day09.qy;

import day09.Person;

/\*\*

\* 继承不同包的父类

\* \*/

public class Worker extends Person\{

public void dowork() \{

//子类是否可以访问父类的private 、default（默认成员）、protected 、public

//this.tel=21;//私有成员不可直接访问

//this.name="尊";//默认成员在不同包中也不可访问

this.address="中国";//protected 修饰的成员可以在不同包的子类中访问

package day09.qy;

public class TestDemo \{

public static void main(String\[\] args) \{

// TODO 自动生成的方法存根

//初始化worker对象

Worker worker=new Worker();

//设置子类属性

//worker.name="尊";//使用的是默认权限修饰符，不能访问到

//worker.address="中国";//可以在不同包的子类中使用

输出结果：

![70 1][]

1.4继承的练习题

package day09.Test1;

public class Animal \{

private String name;//名字

private int 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;

//行为

public void doEat() \{

System.out.println("吃东西");

//构造方法

public Animal() \{

// TODO 自动生成的构造函数存根

System.out.println("父类默认构造方法");

public  Animal(String name,int age) \{

System.out.println("父类带参数构造方法");

//给父类属性赋值

this.name=name;

this.age=age;

package day09.Test1;

public class Cat extends Animal\{

//设置子类特有属性

private String sex;

public String getSex() \{

return sex;

public void setSex(String sex) \{

this.sex = sex;

//特有行为

public void upperTree() \{

System.out.println("猫可以上树");

public Cat() \{

// TODO 自动生成的构造函数存根

System.out.println("猫的默认构造方法");

public  Cat(String name,int age) \{

//调用父类带参数的构造方法  直接给父类属性赋值

super(name,age);

package day09.Test1;

public class Dog extends Animal\{

//属性

private int weight;

public int getWeight() \{

return weight;

public void setWeight(int weight) \{

this.weight = weight;

//行为

public void swimming() \{

System.out.println("狗会游泳");

public Dog() \{

// TODO 自动生成的构造函数存根

public  Dog(String name,int age) \{

super(name,age);

package day09.Test1;

public class TestDemo \{

public static void main(String\[\] args) \{

// TODO 自动生成的方法存根

//初始化cat对象

Cat cat=new Cat("Tom",2);

//设置sex

cat.setSex("公");

//获取name和age属性

System.out.println(cat.getName());//子类没有找父类

System.out.println(cat.getAge());

System.out.println(cat.getSex());

//调用公共方法

cat.doEat();

//初始化dog对象

Dog dog=new Dog("ww", 4);

dog.setWeight(20);

System.out.println(dog.getName());

System.out.println(dog.getAge());

System.out.println(dog.getWeight());

dog.doEat();

dog.swimming();

输出结果：

![70 2][]

1.5重写

/\*\*

\* 重写 只能是方法 只能重写父类的方法

\* 当父类的功能满足不了子类特性， 子类需要对父类的方法重新定义

\* 1.必须在子类中重写

\* 2.方法名 参数列表必须一致

\* 3.修饰符要嘛和父类一致，要嘛比父类修饰符权限大

\* 4.子类方法的返回值类型是和父类方法的返回类型相同或者是其子类。

\* 5.方法中声明的异常要么一致  要么获取子类类型

\* \*/

package day09.Test2;

public class Animal \{

private String name;//名字

private int 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;

//行为

public void doEat() \{

System.out.println("吃东西");

//构造方法

public Animal() \{

// TODO 自动生成的构造函数存根

System.out.println("父类默认构造方法");

public  Animal(String name,int age) \{

System.out.println("父类带参数构造方法");

//给父类属性赋值

this.name=name;

this.age=age;

package day09.Test2;

public class Cat extends Animal\{

//设置子类特有属性

private String sex;

public String getSex() \{

return sex;

public void setSex(String sex) \{

this.sex = sex;

//特有行为

public void upperTree() \{

System.out.println("猫可以上树");

public Cat() \{

// TODO 自动生成的构造函数存根

System.out.println("猫的默认构造方法");

public  Cat(String name,int age) \{

//调用父类带参数的构造方法  直接给父类属性赋值

super(name,age);

@Override //注解

public void doEat() \{//重写父类方法

// TODO 自动生成的方法存根

//super.doEat();//调用父类的方法

System.out.println("猫吃鱼，喵喵喵");

package day09.Test2;

public class Dog extends Animal\{

//属性

private int weight;

public int getWeight() \{

return weight;

public void setWeight(int weight) \{

this.weight = weight;

//行为

public void swimming() \{

System.out.println("狗会游泳");

public Dog() \{

// TODO 自动生成的构造函

public  Dog(String name,int age) \{

super(name,age);

@Override

public void doEat() \{

// TODO 自动生成的方法存根

System.out.println("狗喜欢吃肉，汪汪汪");

//如果保留父类行为  可以使用super调用父类方法

super.doEat();

package day09.Test2;

public class TestDemo \{

public static void main(String\[\] args) \{

// TODO 自动生成的方法存根

//初始化cat对象

Cat cat=new Cat("Tom",2);

//设置sex

cat.setSex("公");

cat.doEat();

cat.upperTree();

//初始化dog对象

Dog dog=new Dog("ww", 4);

dog.setWeight(20);

dog.doEat();

dog.swimming();

输出结果：

![70 3][]

1.6object类

<table style="margin-left:6.75pt;width:437pt;"> 
 <tbody> 
 <tr> 
 <td style="background-color:#1293cd;width:104.25pt;"> 方法 </td> 
 <td style="background-color:#1293cd;width:332.75pt;"> 说明 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#e9f9fd;width:104.25pt;"> toString() </td> 
 <td style="background-color:#e9f9fd;width:332.75pt;"> 返回当前对象本身的有关信息，按字符串对象返回 </td> 
 </tr> 
 <tr> 
 <td style="width:104.25pt;"> equals() </td> 
 <td style="width:332.75pt;"> 比较两个对象是否是同一个对象，是则返回true </td> 
 </tr> 
 <tr> 
 <td style="background-color:#dae3f3;width:104.25pt;"> hashCode() </td> 
 <td style="background-color:#dae3f3;width:332.75pt;"> 返回该对象的哈希代码值 </td> 
 </tr> 
 <tr> 
 <td style="width:104.25pt;"> getClass() </td> 
 <td style="width:332.75pt;"> 获取当前对象所属的类信息，返回Class对象 </td> 
 </tr> 
 </tbody> 
</table>

package day09.Test3;

public class Student \{

//属性

String name;

int age;

//重写toString

@Override

public String toString() \{

// TODO 自动生成的方法存根

return name+"  "+age;

public static void main(String\[\] args) \{

// TODO 自动生成的方法存根

//初始化student对象

Student stu=new Student();

Student stu1=stu;

System.out.println("stu=="+stu+"\\nstu1=="+stu1);

//判断两个对象是否相等  恒等== 内存引用

if (stu.equals(stu1)) \{

System.out.println("相等");

\}else \{

System.out.println("不相等");

//String 类型判断的是内容 其他类引用地址

String str=new String("123");

String str1=new String("1234");

if (str.equals(str1)) \{

System.out.println("内容相等");

\}else \{

System.out.println("内容不相等");

stu.name="尊";

stu.age=21;

String msg=stu.toString();

System.out.println(msg);

输出结果：

![70 4][]

1.7重写练习题

重写比较规则，判断两名学员（Student）是否为同一对象

Student相关属性：Id（学号）、name（姓名）、age（年龄）

如果两名学员的学号以及姓名相同，则为同一对象

package day09.Test4;

public class Student \{

//设置属性

private int id;

private String name;

private int age;

public int getId() \{

return id;

public void setId(int id) \{

this.id = id;

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;

@Override

public boolean equals(Object obj) \{

Student stu=(Student)obj;

//instanceof用于判断一个引用类型所引用的对象是否是一个类的实例

if (stu instanceof Student) \{

if(this.age==stu.getAge()&&this.name==stu.getName()&&this.id==stu.getId())\{

return true;

return false;

public static void main(String\[\] args) \{

// TODO 自动生成的方法存根

Student stu1=new Student();

stu1.setId(1);

stu1.setName("尊");

stu1.setAge(21);

Student stu2=new Student();

stu2.setId(11);

stu2.setName("尊");

stu2.setAge(21);

if (stu1.equals(stu2)) \{

System.out.println("是同一个人");

\}else \{

System.out.println("不是同一个人");

输出结果：

![70 5][]

2.知识框架

![70 6][]

[70]: /images/20220518/6ed8f4a03fe44a9388e967cdf86c3dab.png
[70 1]: /images/20220518/5b21705a60644ec2a1a5146b57f241e9.png
[70 2]: /images/20220518/8f82a025b6c449b3aa9403d8758cfc45.png
[70 3]: /images/20220518/ba70ddaa7d6d48759be15896c81eeebe.png
[70 4]: /images/20220518/f88f5df95e0a436fa6d0b35710dee5a9.png
[70 5]: /images/20220518/8c50e6c7192a41c9ba0639d9b056e65e.png
[70 6]: /images/20220518/c21a84867c92430e835ac9068165212a.png