【07】面对对象3_继承,super,函数覆盖,子类实例化,final,抽象,接口

最新推荐文章于 2021-11-19 20:37:38 发布

亲爱的Du

最新推荐文章于 2021-11-19 20:37:38 发布

阅读量1.1k

点赞数

分类专栏： Java基础文章标签：面对对象3 继承 super 函数覆盖子类实例化

本文链接：https://blog.csdn.net/duguang77/article/details/9359027

版权

Java基础专栏收录该内容

43 篇文章 0 订阅

订阅专栏

继承

---------------------------------------------------------------------------------------------------------------------------------

4.1 继承的概述

4.2 继承的特点

4.3super关键字

4.4 函数覆盖

4.5 子类的实例化过程

4.6final关键字

4.7抽象

4.8接口

---------------------------------------------------------------------------------------------------------------------------------

4.1继承的概述

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继那个类即可。

多个类可以称为子类，单独这个类称为父类或者超类。

子类可以直接访问父类中的非私有的属性和行为。

通过 extends 关键字让类与类之间产生继承关系。

class SubDemo extends Demo{}

继承的优点：

继承的出现提高了代码的复用性。

继承的出现让类与类之间产生了关系，提供了多态的前提。

注意：千万不要为了获取其他类的功能，简化代码而继承。

必须是类与类之间有所属关系才可以继承。所属关系是 is a。

练习一：

/*
将学生和工人的共性描述提取出来，单独进行描述，
只要让学生和工人与单独描述的这个类有关系，就可以了。
*/
 
class Person
{
         String name;
         int age;
}
class Student extends Person
{
                   void study()
         {
                   System.out.println("goodstudy");
         }
}
 
class Worker extends Person
{
         void work()
         {
                   System.out.println("goodwork");
         }
}
 
class ExtendsDemo
{
         public static void main(String[] args)
         {
                   Student s = new Student();
                   s.name= "zhagnsan";
         }
}
 
/*

4.2 继承的特点

Java只支持单继承，不支持多继承。

一个类只能有一个父类，不可以有多个父类。

class SubDemoextends Demo{} //ok

class SubDemoextends Demo1,Demo2...//error

Java支持多层继承(继承体系)

class A{}

class B extendsA{}

class C extendsB{}

定义继承需要注意：

不要仅为了获取其他类中某个功能而去继承

类与类之间要有所属( " is a " )关系，xx1是xx2的一种。

练习二：

/*
Java语言中：java只支持单继承，不支持多继承。
 
因为多继承容易带来安全隐患:当多个父类中定义了相同功能，
当功能内容不同时，子类对象不确定要运行哪一个。
但是java保留这种机制。并用另一种体现形式来完成表示。多实现。
*/
 
 
class C //A,B的父类
{
         void demo1(){}
}
 
class A extends C
{
         //void demo1(){}
         void demo2(){}
}
 
class B extends C
{
         //void demo1(){}
         void demo3(){}
}

练习三：

/*
java支持多层继承。也就是一个继承体系
 
如何使用一个继承体系中的功能？
 
想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性功能。
通过了解共性功能，就可以知道该体系的基本功能。那么这个体系已经可以基本使用了。
 
在具体调用时，要创建最子类的对象，为什么呢？
一是因为有可能父类不能创建对象，
二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。
 
简单一句话：查阅父类功能，创建子类对象使用功能。
 
class A
{
         String name;
         intage;
 
}
class B extends A
{
         void show()
         {
                   System.out.println("b");
         }
}
 
class C extends B
{}
*/
 
聚集的关系：has a //谁里面有谁

4.3super关键字

子父类出现后，类成员的特点：

类中成员：

1，变量。

2，函数。

3，构造函数。

1,变量

如果子类中出现非私有的同名成员变量时，

子类要访问本类中的变量，用this

子类要访问父类中的同名变量，用super

super和this的区别？

super的使用和this的使用几乎一致。

this代表的是本类对象的引用。

super代表的是父类对象的引用。

练习四：super和this的区别

class Fu
{
         private int num = 4;
         public void setNum(int num)
         {
                   this.num=num;
         }
         public int getNum()
         {
                   returnthis.num;
         }
}
 
class Z1 extends Fu
{
         int num = 5;
         void show()
         {
                   System.out.println(super.num);//输出为 4
                   System.out.println(this.num);//输出为 5
         }
}
 
class ExtendsDemo2
{
         public static void main(String[] args)
         {
                   Ziz = new Zi();
                   z.show();
                   //System.out.println(z.num+"...."+z.num);
         }
}

4.4函数重写(覆盖)

概念：子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者复写。

父类中的私有方法不可以被覆盖。

在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。

覆盖注意事项：

覆盖时，子类方法权限一定要大于等于父类方法权限

静态只能覆盖静态。

覆盖的应用：

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

覆盖：

1，子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。

2，静态只能覆盖静态。

重写和重载区别？

重载：只看同名函数的参数列表。

重写：子父类方法要一模一样。

练习五：函数重写(覆盖)

class Fu
{
         void show()
         {
                   System.out.println("fushow");
         }
         void speak()
         {
                   System.out.println("vb");
         }
}
 
class Zi extends Fu
{
         void speak()
         {
                   System.out.println("java");
         }
         void show()
         {
                   System.out.println("zishow");
         }
}
 
 
class ExtendsDemo3
{
         public static void main(String[] args)
         {
                   Zi z = new Zi();
                   z.speak();
 
         }
}

练习六：函数重写(覆盖)

class Tel
{
         void show()
         {
                   System.out.println("number");
         }
        
}
 
class NewTel extends Tel
{
         void show()
         {
                   //System.out.println("number");
                   super.show();
                   System.out.println("name");
                   System.out.println("pic");
         }
}

练习七：子父类中的构造函数。

/*
在对子类对象进行初始化时，父类的构造函数也会运行，
那是因为子类的构造函数默认第一行有一条隐式的语句 super();
super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();
 
为什么子类一定要访问父类中的构造函数。
 
因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。
所以子类在对象初始化时，要先访问一下父类中的构造函数。
如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。
 
注意：super语句一定定义在子类构造函数的第一行。
 
子类的实例化过程，结论：
 
子类的所有的构造函数，默认都会访问父类中空参数的构造函数。
因为子类每一个构造函数内的第一行都有一句隐式super();
 
当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。
 
当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。
子类中至少会有一个构造函数会访问父类中的构造函数。
*/
class Fu //extends Object
{
         int num ;
         Fu()
         {
                   //super();
                   num=60;
                   System.out.println("furun");
         }
         Fu(int  x)
         {
                   System.out.println("fu...."+x);
         }
        
}
 
class Zi extends Fu
{
         Zi()
         {
                  
                   super(); 
                   //super(4);
                   System.out.println("zirun");
         }
         Zi(intx)
         {
                   this();
                   //super();
                   //super(3);
                   System.out.println("zi..."+x);
         }
}
 
class ExtendsDemo4
{
         public static void main(String[] args)
         {
                   Zi z = new Zi(0);
                   System.out.println(z.num);
         }
}

4.5final：最终

final可以修饰类，方法，变量。

final修饰的类不可以被继承。

final修饰的方法不可以被覆盖。

final修饰的变量是一个常量。只能被赋值一次。

内部类只能访问被final修饰的局部变量。

练习八：Final的应用

class Demo
{
         final int x = 3;
         public static final double PI = 3.14;
         final void show1()
         {}
         void show2()
         {
                   final int y = 4;
                   System.out.println(3.14);
         }
}
class SubDemo extends Demo
{
         //voidshow1(){}
}
class FinalDemo
{
         public static void main(String[] args)
         {
                   System.out.println("HelloWorld!");
         }
}

4.7抽象

概念：抽象就是从多个事物中将共性的，本质的内容抽取出来。

例如：狼和狗共性都是犬科，犬科就是抽象出来的概念。

抽象类：

Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。

抽象方法的由来：

多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。

例如：狼和狗都有吼叫的方法，可是吼叫内容是不一样的。所以抽象出来的犬科虽然有吼叫功能，但是并不明确吼叫的细节。

4.7.2抽象类的特点

1.抽象类和抽象方法必须用abstract关键字来修饰。

2.抽象方法只有方法声明，没有方法体，定义在抽象类中。

格式：修饰符abstract 返回值类型函数名(参数列表) ;

3.抽象类不可以被实例化，也就是不可以用new创建对象。原因如下：

抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实例。例如：犬科是一个抽象的概念，真正存在的是狼和狗。

而且抽象类即使创建了对象，调用抽象方法也没有意义。

4.抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类。

4.7.3抽象类和一般类区别?

1.该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。

这些不确定的部分，也是该事物的功能，需要明确出现。但是无法定义主体。

通过抽象方法来表示。

2.抽象类比一般类多个了抽象函数。就是在类中可以定义抽象方法。

3.抽象类不可以实例化。

特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

4.7.4抽象关键字abstract不可以和哪些关键字共存？

abstract 关键字，和哪些关键字不能共存。

final：被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类。

private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。

而抽象方法出现的就是需要被复写。

static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。

可是抽象方法运行没意义。

4.7.5抽象类中是否有构造函数？

有，抽象类是一个父类，要给子类提供实例的初始化。

4.7.6抽象类中可不可以没有抽象方法？

可以

练习九：Abstract

/*
假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：
姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个
奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方
法进行属性访问。
 
员工类：name id pay
 
经理类：继承了员工，并有自己特有的bonus。
 
*/
 
abstract class Emplyee
{
         private String name;
         private String id;
         private Double pay;
        
         Emplyee(Stringname,String id,Double pay)
         {
                   this.name= name;
                   this.id= id;
                   this.pay= pay;
         }
 
         public abstract void work();
}
 
class Manager extends Emplyee
{
         private int bouns;
         Manager(Stringname,String id,Double pay,int bonus)
         {
                   super(name,id,pay);
                   this.bouns= bouns;
         }
 
         public void work()
         {
                   System.out.println("Managerwork");
         }
}
 
class Pro extends Emplyee
{
         Pro(Stringname,String id,Double pay)
         {
                   super(name,id,pay);
         }
 
         public void work()
         {
                   System.out.println("Prowork");
         }
}
        
 
class AbstractDemo
{
         public static void main(String[] args)
         {
                   Managerm = new Manager("张三","001",12000.00,5000);
                   m.work();
                   Prop1 = new Pro("李四","022",8000.00);
                   p1.work();
 
         }
}

4.7.7什么是模版方法呢？

在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去。由该类的子类去完成。

练习十：获取一段程序运行的时间 Abstract+Final的应用

/*
需求：获取一段程序运行的时间。
原理：获取程序开始和结束的时间并相减即可。
 
获取时间：System.currentTimeMillis();
 
当代码完成优化后，就可以解决这类问题。
 
这种方式，模版方法设计模式。
 
*/
 
abstract class GetTime
{
         public final void getTime() //final修饰下，不让其他子类复写
         {
                   long start = System.currentTimeMillis();
 
                   run Code();
        
                   long end = System.currentTimeMillis();
 
                   System.out.println("耗时："+(end-start));
         }
         public abstract void runCode();
}
 
class RunCode extends GetTime
{
         public void runCode()
         {
                   for(int x=0; x<4000; x++)
                   {
                            System.out.print(x);
                   }
         }
}
 
 
class GetTimeDemo
{
         public static void main(String[] args)
         {
                   Run Codegt = new RunCode();
                   gt.getTime();
         }
}

4.8接口

4.8.1接口的概念：初期理解，可以认为是一个特殊的抽象类

当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。

class用于定义类

interface用于定义接口。

4.8.2接口的格式：

interface {}

接口中的成员修饰符是固定的。

成员常量：publicstatic final

成员函数：publicabstract

发现接口中的成员都是public的。

接口的出现将“多继承”通过另一种形式体现出来，即“多实现”

4.8.3接口注意事项：

接口：是不可以创建对象的，因为有抽象方法。

需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。

否则子类是一个抽象类。

接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。

4.8.4怎样实现多继承？

java只有在接口和接口之间才能实现多继承

类与类之间只能实现单继承，而接口让类与类多实现

4.8.5接口的特点

1.接口是对外暴露的规则。

2.接口是程序的功能扩展。

3.接口的出现降低耦合性。

4.接口可以用来多实现。

5.类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。

6.接口与接口之间可以有继承关系。

4.8.6接口与抽象类

练习十一：单继承过后的类，接口的多实现

interface Inter
{
         public static final int NUM = 3;
         public abstract void show();
}
 
interface InterA
{
         public abstract void show();
}
 
class Demo
{
         public void function(){}
}
 
//一个类继承一个类，还能多实现
class Test extends Demo implementsInter,InterA
{
         public void show(){}
}
 
//接口A
interface A
{
         void methodA();//由接口自动填写 public static这两个关键字
}
 
//接口B
interface B //extends A
{
         void methodB();
}
 
//java只有在接口和接口之间才能实现多继承
//接口C
interface C extends B,A
{
         voidmethodC();
}
 
//一般类D实现接口C
class D implements C
{
         public void methodA(){}
         public void methodC(){}
         public void methodB(){}
}
 
class InterfaceDemo
{
         public static void main(String[] args)
         {
                   Testt = new Test();
                   System.out.println(t.NUM);
                   System.out.println(Test.NUM);
                   System.out.println(Inter.NUM);
                   //t.NUM,Test.NUM, Inter.NUM指向的都是一个常量，输出结果是 3
         }
}

练习十二：有的学生吸烟，有的学生喝酒

/*
abstract class Student
{
         abstractvoid study();
         void sleep()
         {
                   System.out.println("sleep");
         }
 
}
 
interface Smoking
{
         void smoke();
}
 
class ZhangSan extends Student implementsSmoking
{
         void study(){}
         public void smoke(){}
}
class Lisi extends Student
{
}
*/
 
class 
{
         public static void main(String[] args)
         {
                   System.out.println("HelloWorld!");
         }
}

亲爱的Du

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【07】面对对象3_继承,super,函数覆盖,子类实例化,final,抽象,接口

继承---------------------------------------------------------------------------------------------------------------------------------4.1 继承的概述4.2 继承的特点4.3super关键字4.4 函数覆盖4.5 子类的实例化过程4.6fin
复制链接

扫一扫