基础学习day07---面向对象三---继承,接口与 抽象类

一、继承

1.1、继承概念

将对象的共性抽取出来。提取出一个单独的类。

继承使用复用以前的代码非常容易,能够大大的缩短开发周期,降低开发成本,同时增加程序的易维护性

继承使重一个类A能够直接使用另外一个类B的属性和方法的一种途径

类A可以有自己的属性和方法通过 extends 关键字让类与类之间产生继承关系。

让类和类之间产生了关系,有了这个关系,才有了多态的特性。

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

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

1.2、继承的实现

类的继承格式

在Java中使用extends关键字完成类的继承关系,操作格式:

class 父类{} // 定义父类

class 子类 extends 父类{} // 使用extends关键字实现继承

1.3、继承的特点

子类继承父类的什么?

继承public 和protected修饰的属性和方法,不管子类和父类是不是在一个包中

继承默认权限修饰的属性和方法,子类和父类必须在同一个包中

注意:

JAVA只支持单继承,也就是一个类只能继承一个类

无法继承private修饰的属性和方法

无法继承父类的构造方法

子类继承了父类的所有属性(包括private)和方法或子类拥有父类的所有属性和方法是对的,只不过父类的私有属性和方法,子类是无法直接访问到的。即只是拥有,但是无法使用。

示例:

package com.study.day07.person;
/**
 * 父类
 * @author denny
 *
 */
public class Person {
    /**
     * name=姓名
     * age=年龄
     * 都是私有的
     */
 private     String name;
    private int age;

    /**
     * 无参数构造方法
     */
    public Person() {
        System.out.println("父类无参数的构造方法");
    }

    /**
     * 有参数构造方法
     * @param name=姓名
     * @param age=年龄
     */
    public Person(String name, int age) {

        this.name = name;
        this.age = age;
        System.out.println("父类有参数的构造方法");
    }

    /**
     * 显示信息方法
     */
    public void show(){
        System.out.println("父类show方法");
        System.out.println("姓名: "+this.name+" \n年龄: "+this.age);
    }

    /**
     * getterXxx和setterXxx方法
     * @return
     */
    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.study.day07.person;
/**
 * 学生类继承父类
 * @author denny
 *
 */
public class Student extends Person {
    /**
     * gender=性别
     * 子类特有的属性
     */
    private String gender;

    /**
     * 子类无参数构造方法
     */
    public Student() {
        super();//使用父类的构造方法
        System.out.println("子类无参数构造方法");
    }

    public Student(String name,int age,String gender) {
        /*
         * 调用父类有参数的构造方法
         */
        super(name,age);
        this.gender = gender;
        System.out.println("子类有参数构造方法");
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
    /**
     * 重写父类的方法
     */
    @Override
    public void show(){
        super.show(); //调用父类的方法,
        System.out.println("子类show方法");
        System.out.println("性别: "+this.gender); //子类自己的方法体
    }

}

测试类

package com.study.day07.person;

import com.study.day07.person.Person;

public class Test {

    public static void main(String[] args) {
        Person s=new Student("张三",20,"男");

        s.show();

    }

}

结果:

父类有参数的构造方法
子类有参数构造方法
父类show方法
姓名: 张三
年龄: 20
子类show方法
性别: 男

在子类构造函数执行时,发现父类构造函数也运行了。
原因:在子类的构造函数中,第一行有一个默认的隐式语句:super();

1.4、方法重写

上例中子类show()实现的对父类show()方法的重写.

/**
     * 重写父类的方法
     */
    @Override
    public void show(){
        super.show(); //调用父类的方法,
        System.out.println("子类show方法");
        System.out.println("性别: "+this.gender); //子类自己的方法体
    }
    

在子类覆盖方法中,继续使用父类的方法可以通过super.函数名获取 ,super.变量名

什么时候使用覆盖操作?
当子类需要父类的功能,而功能主体子类有自己特有内容时,可以复写父类中的方法,这样,即沿袭了父类的功能,又定义了子类特有的内容。

注意:

 1、父类中的私有方法不可以被覆盖。
 2、父类为static的方法无法覆盖。
 3、覆盖时,子类方法权限一定要大于等于父类方法权限。

 1.5、子类的实例化过程

子类中所有的构造函数默认都会访问父类中空参数的构造函数。
    因为每一个构造函数的第一行都有一条默认的语句super();。

为什么子类实例化的时候要访问父类中的构造函数呢?
那是因为子类继承了父类,获取到了父类中内容(属性),所以在使用父类内容之前,要先看父类是如何对自己的内容进行初始化的。

注意:

1、当父类中没有空参数的构造函数时,子类的构造函数必须通过this或者super语句指定要访问的构造函数。
2、子类构造函数中如果使用this调用了本类构造函数,那么默认的super(),就没有了,因为super和this都只能定义在第一行,所以只能有一个。但是可以保证的是,子类中肯定会有其他的构造函数访问父类的构造函数。
3、super语句必须要定义在子类构造函数的第一行!因为父类的初始化动作要先完成。

 总结:

一个对象实例化过程,以Person p = new Person();为例:
    1. JVM会读取指定的路径下的Person.class文件,并加载进内存,并会先加载Person的父类(如果有直接的父类的情况下)。
    2. 在内存中开辟空间,并分配地址。
    3. 并在对象空间中,对对象的属性进行默认初始化。
    4. 调用对应的构造函数进行初始化。
    5. 在构造函数中,第一行会先到调用父类中构造函数进行初始化。
    6. 父类初始化完毕后,再对子类的属性进行显示初始化。
    7. 再进行子类构造函数的特定初始化。
    8. 初始化完毕后,将地址值赋值给引用变量。

二、final

 

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

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

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

为什么要用final修饰变量,其实,在程序中如果一个数据是固定的。那么直接使用这个数据就可以了,但是这种阅读性差,所以应该给数据起个名称。而且这个变量名称的值不能变化,所以加上final固定。
写法规范:常量所有字母都大写,多个单词,中间用_连接。

/*
final 修饰的变量是常量不可更改其值

*/
class FinalDemo{

    public static void main(String [] args){

    final int x=5;
    x=4;
    System.out.println("x="+x);
    }

}

结果:

三、抽象类和抽象类和方法

3.1、抽象类概述

使用关键字abstract 来修饰

抽象定义:
 抽象就是从多个事物中将共性的、本质的内容抽取出来。
 例如:学生和老师都是人,人类就是抽象出来的共性。

抽象类:使用abstract 修饰。
 抽象方法:Java中可以定义没有方法体的方法,该方法的具体实现由子类完成,该方法称为抽象方法,包含抽象方法的类就是抽象类。使用abstract来修饰

3.2、抽象类特点

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

抽象方法只有方法声明,没有方法体,定义在抽象类中。
格式:修饰符 abstract 返回值类型 函数名(参数列表) ;

 抽象类不可以被实例化,也就是不可以用new创建对象。
    原因如下:
    1. 抽象类是具体事物抽取出来的,本身是不具体的,没有对应的实例。例如:犬科是一个抽象的概念,真正存在的是狼和狗。
    2. 而且抽象类即使创建了对象,调用抽象方法也没有意义。
    3. 抽象类通过其子类实例化,而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象,否则该子类也是抽象类。

示例:

package com.day08.abstrac.demo1;
/**
 * 定义人类抽象类
 * @author denny
 *
 */
public abstract class Person {

    /**
     * 定义属性
     * name=姓名
     * age=年龄
     * gender=性别
     */
    private String name;
    private int age;
    private String gender;

    /**
     * 抽象方法
     */
    public abstract void life();  //生活方法

    /**
     * getter和setter方法
     * @return
     */
    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 String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }

}

子类:

package com.day08.abstrac.demo1;
/**
 * 老师类继承人类抽象类
 * 必须实现人类中的抽象方法
 * 如果不实现老师类必须是抽象类
 * @author denny
 *
 */
public class Teacher extends Person {

    @Override
    public void life() {
        System.out.println("教师的生活就是教学!");

    }

}

3.3、抽象类相关问题

抽象类中是否有构造函数?
    答:有,用于给子类对象进行初始化。

抽象关键字abstract不可以和哪些关键字共存?
    答:private、static、final。

抽象类中可不可以没有抽象方法?
    答:可以,但是很少见。目的就是不让该类创建对象,AWT的适配器对象就是这种类。通常这个类中的方法有方法体,但是却没有内容。

3.4、抽象类和一般类的区别?

相同点:
    抽象类和一般类都是用来描述事物的,都在内部定义了成员。

区别:

抽象类不可以被实例化,一般类可以被实例化

抽象类可以有抽象方法和一般方法,一般类只能有一般的方法

抽象类描述事物的信息有可能不足。一般类有足够的信息描述事物。

抽象类一定是个父类吗?
    答:是的,因为需要子类覆盖其方法后才可以对子类实例化。

四、接口

4.1、接口定义

当一个抽象类中的方法都是抽象的时候,这时可以将该抽象类用另一种形式定义和表示,就是接口。

格式:interface 接口名 {}

接口中的成员修饰符是固定的:
    成员常量:public static final   成员变量都是静态常量
    成员函数:public abstract      所有方法都是抽象方法,可以不写abstract,只能是public,不能是其它的
    由此得出结论,接口中的成员都是公共的权限。

接口是对外暴露的规则。
    接口是程序的功能扩展。

P.S.
    1、虽然接口类中的全局变量和抽象方法的修饰符都可以不用写,但是这样阅读性很差。所以,最好写上。
    2、类与类之间是继承关系,类与接口直接是实现关系。
    3、接口不可以实例化,能由实现了接口并覆盖了接口中所有的抽象方法的子类实例化。否则,这个子类就是一个抽象类。

4.2、接口的实现

类要实现接口要使用implements关键字

格式 class 类名 implements 接口名

1.实现接口时,实现接口中的所有方法

2.

示例:

分别定义接口鸟的叫和攻击方法都是抽象的

package com.day08.interfac.demo1;
/**
 * 攻击接口
 * @author denny
 *
 */
public interface BirdAttack {

    /**
     * 攻击的方法
     * 没有方法体
     */
    public void attack();

}
package com.day08.interfac.demo1;
/**
 * 叫声的接口
 * @author denny
 *
 */
public interface BirdShout {
    /**
     * 叫的方法
     * 没有方法体
     */
    public void shout();
}

火箭鸟

package com.day08.interfac.demo1;
/**
 * 火箭鸟
 * @author denny
 *攻击方式:火箭攻击
 *实现了攻击的接口和叫的接口,所有要重写攻击接口中的叫方法和攻击方法
 *接口可以实现多个,但继承只能有一个
 *
 */
public class FireBird implements BirdAttack,BirdShout{

    @Override
    public void shout() {
        System.out.println("火箭鸟喳喳叫!");
    }

    @Override
    public void attack() {
        System.out.println("火箭鸟发射火箭弾攻击!");

    }

}

胖子鸟

package com.day08.interfac.demo1;
/**
 * 胖子鸟
 * @author denny
 * 叫声:唧唧叫
 * 没有攻击,所以不需要实现攻击的接口
 *
 */
public class FatBird implements BirdShout {

    @Override
    public void shout() {
        System.out.println("胖子鸟唧唧叫!");

    }

}

测试类

package com.day08.interfac.demo1;

public class BirdTest {

    public static void main(String[] args) {
        //创建胖子鸟对象,并调用相应的方法
        FatBird fatBird=new FatBird();
        fatBird.shout();
        //创建火箭鸟对象,并调用相应的方法
        FireBird fireBird=new FireBird();
        fireBird.shout();
        fireBird.attack();

    }

}

结果

胖子鸟唧唧叫!
火箭鸟喳喳叫!
火箭鸟发射火箭弾攻击!

以上例子中,实现的,行为和类的分离,需要哪个就实现哪个接口,没有就不要实现

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

java将多继承机制进行改良,在java中变成了多实现,一个类可以实现多个接口。
    接口的出现避免了单继承的局限性。

4.3、抽象类和接口

相同点:

抽象类和接口都不能被实例化

都是不断向上抽取而来的。

区别:

1. 抽象类需要被继承(extends),而且只能单继承。
        接口需要被实现,而且可以多实现。(implements)
 2. 抽象类中可以定义抽象方法和非抽象方法,子类继承后,可以直接使用非抽象方法。
        接口中只能定义抽象方法,必须由子类去实现。
 3. 抽象类的继承,是is a关系,定义该体系的基本共性内容。
        接口的实现是like a关系。

时间: 2024-10-12 19:09:21

基础学习day07---面向对象三---继承,接口与 抽象类的相关文章

ASP.Net MVC开发基础学习笔记:三、Razor视图引擎、控制器与路由机制学习

一.天降神器“剃须刀” — Razor视图引擎 1.1 千呼万唤始出来的MVC3.0 在MVC3.0版本的时候,微软终于引入了第二种模板引擎:Razor.在这之前,我们一直在使用WebForm时代沿留下来的ASPX引擎或者第三方的NVelocity模板引擎. Razor在减少代码冗余.增强代码可读性和Visual Studio智能感知方面,都有着突出的优势.Razor一经推出就深受广大ASP.Net开发者的喜爱. 1.2 Razor的语法 (1)Razor文件类型:Razor支持两种文件类型,分

C++基础学习教程(三)

承接上一讲. 2.7文件I/O 关于读写文件,C++中有一个专门的头文件<fstream>. 首先是读文件示例,如下: </pre><pre> /************************************************************************* > File Name: list1301_file.cpp > Author: suool > Mail: [email protected] > Cre

js基础学习笔记(三)

3.1 认识DOM 文档对象模型DOM(Document Object Model)定义访问和处理HTML文档的标准方法.DOM 将HTML文档呈现为带有元素.属性和文本的树结构(节点树). 先来看看下面代码: 将HTML代码分解为DOM节点层次图: HTML文档可以说由节点构成的集合,三种常见的DOM节点: 1. 元素节点:上图中<html>.<body>.<p>等都是元素节点,即标签. 2. 文本节点:向用户展示的内容,如<li>...</li&g

java学习--基础知识进阶第三天--接口、多态

今日内容介绍 u 接口 u 多态 第1章 接口 1.1 接口的概述 接口是功能的集合,同样可看做是一种数据类型,是比抽象类更为抽象的"类". 接口只描述所应该具备的方法,并没有具体实现,具体的实现由接口的实现类(相当于接口的子类)来完成.这样将功能的定义与实现分离,优化了程序设计. 1.2 接口的格式&使用 1.2.1 接口的格式 与定义类的class不同,接口定义时需要使用interface关键字. 定义接口所在的仍为.java文件,虽然声明时使用的为interface关键字

java基础学习总结——面向对象1

目录 一.面向过程的思想和面向对象的思想 二.简单理解面向对象 三.面向对象的设计思想 四.对象和类的概念 五.如何抽象出一个类? 六.类(对象)之间的关系 七.Java与面向对象 八.为什么使用面向对象编程? 一.面向过程的思想和面向对象的思想 面向对象和面向过程的思想有着本质上的区别, 作为面向对象的思维来说,当你拿到一个问题时,你分析这个问题不再是第一步先做什么,第二步再做什么,这是面向过程的思维,你应该分析这个问题里面有哪些类和对象,这是第一点,然后再分析这些类和对象应该具有哪些属性和方

毕向东Java视频学习笔记【Day09 继承+接口+抽象类】

Java_Day09 继承+接口+抽象类 构造函数 子父类中的构造函数特点. 在子类构造对象时,发现访问子类构造函数时,父类也运行了. 为什么呢? 因为:在子类的构造函数中第一行有一个默认的隐式语句 super() 子类的实例化过程:子类中所有的构造函数默认都会访问父类中的空参构造函数. 在每个子类构造函数中,都有一个隐式的super()调用父类空参构造函数. 如果想输出22行内容,必须在29行改为super(5),这样可以访问到父类带参数的构造函数. 为什么子类实例化的时候会访问到父类的构造函

C#OOP之八 继承 接口和抽象类

继承 在现实生活中有所谓的"种瓜得瓜.种豆得豆"的说法,在生物学概念上就是"遗传"的概念,在面向对象中"继承"就类似于生物学中的遗传,通过继承,可以更好的实现代码的重用(复用,多次使用的意思).增加扩展性.简化代码等. 下面是现实生活中的引用: 定义与使用继承 继承一次最常用的就是通过合法程序(比如遗嘱)从别人那里接受财产或爵位等,有点类似于世袭制. 另外一个含义,是人从父母那里继承一些特征,如果孩子从父母继承的身高.相貌等特征.那么在什么情况下

《你必须知道的.NET》--面向对象编程:接口和抽象类(Ⅱ)

本节主要介绍: 面向对象思想-多态: 接口: 抽象类. Ⅰ.接口: 接口是包涵一组虚方法的抽象类型,其中每一种方法都有其名称.参数和返回值类型.接口中方法不能包涵任何实现. ex: public interface IHelloWorld { bool CheckFileFormat(string fileName); } 一个类可以实现多个接口,当一个类实现接口时,它不仅要实现该接口中定义的所有方法,还要实现该接口从其他接口中继承的所有方法! Ⅱ.抽象类: 抽象类提供多个派生类共享基类的公共定

python开发学习-day07(面向对象之多态、类的方法、反射、新式类and旧式类、socket编程)

s12-20160227-day07 *:first-child { margin-top: 0 !important; } body>*:last-child { margin-bottom: 0 !important; } /* BLOCKS =============================================================================*/ p, blockquote, ul, ol, dl, table, pre { margin

java基础学习——对面向对象的重识

最近几天在看java的视频,感觉很多东西java语法上很像c#,但是还是有很多内容惊到我: 1,java虚拟机 用过VMWar或者VirtualBox的童鞋都对"虚拟机"这个词有个大致的了解,虚拟机提供了个虚拟的平台,让我们可以模拟一些脱离硬件的环境.java里的虚拟机起到了一个类似以前学过的ODBC驱动程序的作用,它屏蔽了底层的差异,让操作系统通过虚拟机向下面看去,操作系统的感觉都是一样的. 有了这一层东西,我们彻底解开了底层硬件和运行操作系统之间的耦合,实现了一次编译,到处运行的梦