一、继承

1.1、继承概念

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

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

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

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

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

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

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

1.2、继承的实现

类的继承格式

在Java中使用extends关键字完成类的继承关系,操作格式:
class 父类{} // 定义父类
class 子类 extends 父类{} // 使用extends关键字实现继承
 
 1.3、继承的特点
子类继承父类的什么?
继承public 和protected修饰的属性和方法,不管子类和父类是不是在一个包中
继承默认权限修饰的属性和方法,子类和父类必须在同一个包中
注意:
JAVA只支持单继承,也就是一个类只能继承一个类
无法继承private修饰的属性和方法
无法继承父类的构造方法
子类继承了父类的所有属性(包括private)和方法或子类拥有父类的所有属性和方法是对的,只不过父类的私有属性和方法,子类是无法直接访问到的。即只是拥有,但是无法使用。
示例:
  1. package com.study.day07.person;
  2. /**
  3. * 父类
  4. * @author denny
  5. *
  6. */
  7. public class Person {
  8. /**
  9. * name=姓名
  10. * age=年龄
  11. * 都是私有的
  12. */
  13. private String name;
  14. private int age;
  15.  
  16. /**
  17. * 无参数构造方法
  18. */
  19. public Person() {
  20. System.out.println("父类无参数的构造方法");
  21. }
  22.  
  23. /**
  24. * 有参数构造方法
  25. * @param name=姓名
  26. * @param age=年龄
  27. */
  28. public Person(String name, int age) {
  29.  
  30. this.name = name;
  31. this.age = age;
  32. System.out.println("父类有参数的构造方法");
  33. }
  34.  
  35. /**
  36. * 显示信息方法
  37. */
  38. public void show(){
  39. System.out.println("父类show方法");
  40. System.out.println("姓名: "+this.name+" \n年龄: "+this.age);
  41. }
  42.  
  43. /**
  44. * getterXxx和setterXxx方法
  45. * @return
  46. */
  47. public String getName() {
  48. return name;
  49. }
  50.  
  51. public void setName(String name) {
  52. this.name = name;
  53. }
  54.  
  55. public int getAge() {
  56. return age;
  57. }
  58.  
  59. public void setAge(int age) {
  60. this.age = age;
  61. }
  62.  
  63. }

子类

  1. package com.study.day07.person;
  2. /**
  3. * 学生类继承父类
  4. * @author denny
  5. *
  6. */
  7. public class Student extends Person {
  8. /**
  9. * gender=性别
  10. * 子类特有的属性
  11. */
  12. private String gender;
  13.  
  14. /**
  15. * 子类无参数构造方法
  16. */
  17. public Student() {
  18. super();//使用父类的构造方法
  19. System.out.println("子类无参数构造方法");
  20. }
  21.  
  22. public Student(String name,int age,String gender) {
  23. /*
  24. * 调用父类有参数的构造方法
  25. */
  26. super(name,age);
  27. this.gender = gender;
  28. System.out.println("子类有参数构造方法");
  29. }
  30.  
  31. public String getGender() {
  32. return gender;
  33. }
  34.  
  35. public void setGender(String gender) {
  36. this.gender = gender;
  37. }
  38. /**
  39. * 重写父类的方法
  40. */
  41. @Override
  42. public void show(){
  43. super.show(); //调用父类的方法,
  44. System.out.println("子类show方法");
  45. System.out.println("性别: "+this.gender); //子类自己的方法体
  46. }
  47.  
  48. }

测试类

  1. package com.study.day07.person;
  2.  
  3. import com.study.day07.person.Person;
  4.  
  5. public class Test {
  6.  
  7. public static void main(String[] args) {
  8. Person s=new Student("张三",20,"男");
  9.  
  10. s.show();
  11.  
  12. }
  13.  
  14. }

结果:

  1. 父类有参数的构造方法
  2. 子类有参数构造方法
  3. 父类show方法
  4. 姓名: 张三
  5. 年龄: 20
  6. 子类show方法
  7. 性别:

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

1.4、方法重写

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

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

在子类覆盖方法中,继续使用父类的方法可以通过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固定。
写法规范:常量所有字母都大写,多个单词,中间用_连接。

  1. /*
  2. final 修饰的变量是常量不可更改其值
  3.  
  4. */
  5. class FinalDemo{
  6.  
  7. public static void main(String [] args){
  8.  
  9. final int x=5;
  10. x=4;
  11. System.out.println("x="+x);
  12. }
  13.  
  14. }

结果:

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

3.1、抽象类概述

使用关键字abstract 来修饰

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

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

3.2、抽象类特点

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

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

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

示例:

  1. package com.day08.abstrac.demo1;
  2. /**
  3. * 定义人类抽象类
  4. * @author denny
  5. *
  6. */
  7. public abstract class Person {
  8.  
  9. /**
  10. * 定义属性
  11. * name=姓名
  12. * age=年龄
  13. * gender=性别
  14. */
  15. private String name;
  16. private int age;
  17. private String gender;
  18.  
  19. /**
  20. * 抽象方法
  21. */
  22. public abstract void life(); //生活方法
  23.  
  24. /**
  25. * getter和setter方法
  26. * @return
  27. */
  28. public String getName() {
  29. return name;
  30. }
  31. public void setName(String name) {
  32. this.name = name;
  33. }
  34. public int getAge() {
  35. return age;
  36. }
  37. public void setAge(int age) {
  38. this.age = age;
  39. }
  40. public String getGender() {
  41. return gender;
  42. }
  43. public void setGender(String gender) {
  44. this.gender = gender;
  45. }
  46.  
  47. }

子类:

  1. package com.day08.abstrac.demo1;
  2. /**
  3. * 老师类继承人类抽象类
  4. * 必须实现人类中的抽象方法
  5. * 如果不实现老师类必须是抽象类
  6. * @author denny
  7. *
  8. */
  9. public class Teacher extends Person {
  10.  
  11. @Override
  12. public void life() {
  13. System.out.println("教师的生活就是教学!");
  14.  
  15. }
  16.  
  17. }

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.

示例:

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

  1. package com.day08.interfac.demo1;
  2. /**
  3. * 攻击接口
  4. * @author denny
  5. *
  6. */
  7. public interface BirdAttack {
  8.  
  9. /**
  10. * 攻击的方法
  11. * 没有方法体
  12. */
  13. public void attack();
  14.  
  15. }
  1. package com.day08.interfac.demo1;
  2. /**
  3. * 叫声的接口
  4. * @author denny
  5. *
  6. */
  7. public interface BirdShout {
  8. /**
  9. * 叫的方法
  10. * 没有方法体
  11. */
  12. public void shout();
  13. }

火箭鸟

  1. package com.day08.interfac.demo1;
  2. /**
  3. * 火箭鸟
  4. * @author denny
  5. *攻击方式:火箭攻击
  6. *实现了攻击的接口和叫的接口,所有要重写攻击接口中的叫方法和攻击方法
  7. *接口可以实现多个,但继承只能有一个
  8. *
  9. */
  10. public class FireBird implements BirdAttack,BirdShout{
  11.  
  12. @Override
  13. public void shout() {
  14. System.out.println("火箭鸟喳喳叫!");
  15. }
  16.  
  17. @Override
  18. public void attack() {
  19. System.out.println("火箭鸟发射火箭弾攻击!");
  20.  
  21. }
  22.  
  23. }

胖子鸟

  1. package com.day08.interfac.demo1;
  2. /**
  3. * 胖子鸟
  4. * @author denny
  5. * 叫声:唧唧叫
  6. * 没有攻击,所以不需要实现攻击的接口
  7. *
  8. */
  9. public class FatBird implements BirdShout {
  10.  
  11. @Override
  12. public void shout() {
  13. System.out.println("胖子鸟唧唧叫!");
  14.  
  15. }
  16.  
  17. }

测试类

  1. package com.day08.interfac.demo1;
  2.  
  3. public class BirdTest {
  4.  
  5. public static void main(String[] args) {
  6. //创建胖子鸟对象,并调用相应的方法
  7. FatBird fatBird=new FatBird();
  8. fatBird.shout();
  9. //创建火箭鸟对象,并调用相应的方法
  10. FireBird fireBird=new FireBird();
  11. fireBird.shout();
  12. fireBird.attack();
  13.  
  14. }
  15.  
  16. }

结果

  1. 胖子鸟唧唧叫!
  2. 火箭鸟喳喳叫!
  3. 火箭鸟发射火箭弾攻击!

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

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

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

4.3、抽象类和接口

相同点:

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

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

区别:

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

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

  1. 拒绝从入门到放弃_《鸟哥的 Linux 私房菜 — 基础学习篇(第三版)》必读目录

    目录 目录 前言 关于这本书 必看知识点 最后 前言 相信部分刚进入这个行业的新同学会对一个问题感到疑惑,为什么从培训学校出来的学员不被欢迎? 这里记录下一些我个人的看法(博主也曾有面试新员工的经历) ...

  2. Java学习笔记10(面向对象三:接口)

    接口: 暂时可以理解为是一种特殊的抽象类 接口是功能的集合,可以看作是一种数据类型,是比抽象类更抽象的"类" 接口只描述所应该具备的方法,并没有具体实现,具体实现由接口的实现类(相 ...

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

    目录 一.面向过程的思想和面向对象的思想 二.简单理解面向对象 三.面向对象的设计思想 四.对象和类的概念 五.如何抽象出一个类? 六.类(对象)之间的关系 七.Java与面向对象 八.为什么使用面向 ...

  4. 零基础学习Linux(三)linux与windows文件共享

    上次的博文零基础学习Linux(一)环境搭建中我们已经将linux环境部署完毕了,接下来我们就可以在linux上进行软件的安装和环境的配置.但在进行这些操作之前,我们还需要解决一个问题——Linux与 ...

  5. JavaSE学习总结(六)——接口、抽象类、内部类

    一.不需要实例化的原因 看一个示例: package com.zhangguo.chapter5.s1; /**动物园*/ public class Zoo { public static void ...

  6. day27 多态 多继承 接口类 抽象类

    简单来说:多态就是指一个相同的方法名在不同的对象调用的时候实现一样或者不一样的方法实例1: 动物类有个方法 "嚎叫" 狗类也有个方法 "嚎叫" 猫类继承了动物类 ...

  7. python基础学习Day17 面向对象的三大特性之继承、类与对象名称空间小试

    一.课前回顾 类:具有相同属性和方法的一类事物 实例化:类名() 过程: 开辟了一块内存空间 执行init方法 封装属性 自动的把self返回给实例化对象的地方 对象:实例 一个实实在在存在的实体 组 ...

  8. java基础学习05(面向对象基础01)

    面向对象基础01 1.理解面向对象的概念 2.掌握类与对象的概念3.掌握类的封装性4.掌握类构造方法的使用 实现的目标 1.类与对象的关系.定义.使用 2.对象的创建格式,可以创建多个对象3.对象的内 ...

  9. JavaScript面向对象(三)——继承与闭包、JS实现继承的三种方式

      前  言 JRedu 在之前的两篇博客中,我们详细探讨了JavaScript OOP中的各种知识点(JS OOP基础与JS 中This指向详解 . 成员属性.静态属性.原型属性与JS原型链).今天 ...

  10. python基础学习 Day19 面向对象的三大特性之多态、封装 property的用法(1)

    一.课前内容回顾 继承作用:提高代码的重用性(要继承父类的子类都实现相同的方法:抽象类.接口) 继承解释:当你开始编写两个类的时候,出现了重复的代码,通过继承来简化代码,把重复的代码放在父类中. 单继 ...

随机推荐

  1. 直接把数据库中的数据保存在CSV文件中

    今天突然去聊就来写一个小小的demo喽,嘿嘿 public partial class Form1 : Form { public Form1() { InitializeComponent(); } ...

  2. 【MVC 过滤器的应用】ASP.NET MVC 如何统计 Action 方法的执行时间

    代码如下: using System; using System.Collections.Generic; using System.Diagnostics; using System.Linq; u ...

  3. 二项堆(三)之 Java的实现

    概要 前面分别通过C和C++实现了二项堆,本章给出二项堆的Java版本.还是那句老话,三种实现的原理一样,择其一了解即可. 目录1. 二项树的介绍2. 二项堆的介绍3. 二项堆的基本操作4. 二项堆的 ...

  4. GitHub上那些值得一试的JAVA开源库

    作为一名程序员,你几乎每天都会使用到GitHub上的那些著名Java第三方库,比如Apache Commons,Spring,Hibernate等等.除了这些,你可能还会fork或Star一些其他的开 ...

  5. NPTL 线程同步方式

    NPTL提供了互斥体 pthread_mutex_t 类型进行线程同步,防止由于多线程并发对全局变量造成的不正确操作.使用 pthread_mutext_t 对数据进行保护已经可以实现基本的数据同步, ...

  6. [Solution] ASP.NET Identity(1) 快速入门

    本节将介绍: ASP.NET Identity简介 快速入门 扩展 ASP.NET Identity简介 身份管理在ASP.NET中存在很长世间了,ASP.NET 开发团队已经学会了很多从客户的反馈. ...

  7. MVC怎么在当前视图中,传递参数给到另外一个视图?

    在TransData.cshtml视图中: <div> <!--在一个视图中,请求另外一个视图,并且将数据传到另外一个视图--> <!--视图中调用无返回值的方法,需要加 ...

  8. dp --- CSU 1547: Rectangle

    Rectangle Problem's Link:   http://acm.csu.edu.cn/OnlineJudge/problem.php?id=1547 Mean: 给你一些宽为1或2 的木 ...

  9. 单例(C#版)

    单例: 一个类只有一个实例.巧妙利用了编程语言的一些语法规则:构造函数private, 然后提供一个public的方法返回类的一个实例:又方法和返回的类的实例都是static类型,所以只能被类所拥有, ...

  10. C#开发规范总结(个人建议)

    .NET开发编程规范 章程序的版式 版式虽然不会影响程序的功能,但会影响可读性.程序的版式追求清晰.美观,是程序风格的重要构成因素. 可以把程序的版式比喻为"书法".好的" ...