关闭

面向对象_继承

1419人阅读 评论(0) 收藏 举报
分类:

08.01_面向对象(代码块的概述和分类)(了解)(面试的时候会问,开发不用或者很少用)

  • A:代码块概述
    • 在Java中,使用{}括起来的代码被称为代码块。
  • B:代码块分类
    • 根据其位置和声明的不同,可以分为局部代码块,构造代码块,静态代码块,同步代码块(多线程讲解)
  • C:常见代码块的应用
    • a:局部代码块 (一说局部就和方法有关)
      • 在方法中出现;限定变量生命周期,及早释放,提高内存利用率
    • b:构造代码块 (初始化块)
      • 在类中方法外出现;多个构造方法方法中相同的代码存放到一起,每次创建对象时都执行,并且优先于构造方法执行
    • c:静态代码块
      • 在类中方法外出现,并加上static修饰;用于给类进行初始化,在加载的时候就执行,并且只执行一次。
      • 一般用于加载驱动(例如:mysql链接数据时,把加载驱动等代码放在静态代码块中)

08.02_面向对象(代码块的面试题)(掌握)

  • A:看程序写结果
  • class Student {
        static {
            System.out.println("Student 静态代码块");
        }
    
        {
            System.out.println("Student 构造代码块");
        }
    
        public Student() {
            System.out.println("Student 构造方法");
        }
    }
    
    class Demo2_Student {
        static {
            System.out.println("Demo2_Student静态代码块");
        }
    
        public static void main(String[] args) {
            System.out.println("我是main方法");
    
            Student s1 = new Student();
            Student s2 = new Student();
        }
    }
    

08.03_面向对象(继承案例演示)(掌握)

  • A:继承(extends)
    • 让类与类之间产生关系,子父类关系
  • B:继承案例演示:
    • 动物类,猫类,狗类
    • 定义两个属性(颜色,腿的个数)两个功能(吃饭,睡觉)
  • C:案例演示
    • 使用继承前
  • D:案例演示
    • 使用继承后

08.04_面向对象(继承的好处和弊端)(掌握)

  • A:继承的好处
    • a:提高了代码的复用性
    • b:提高了代码的维护性
    • c:让类与类之间产生了关系,是多态的前提
  • B:继承的弊端

    • 类的耦合性增强了。

    • 开发的原则:高内聚,低耦合。

    • 耦合:类与类的关系
    • 内聚:就是自己完成某件事情的能力

08.05_面向对象(Java中类的继承特点)(掌握)

  • A:Java中类的继承特点
    • a:Java只支持单继承,不支持多继承。(一个儿子只能有一个爹)
      • 有些语言是支持多继承,格式:extends 类1,类2,…
    • b:Java支持多层继承(继承体系)
  • B:案例演示
    • Java中类的继承特点
      • 如果想用这个体系的所有功能用最底层的类创建对象
      • 如果想看这个体系的共性功能,看最顶层的类

08.06_面向对象(继承的注意事项和什么时候使用继承)(掌握)

  • A:继承的注意事项
    • a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
    • b:子类不能继承父类的构造方法,但是可以通过super(马上讲)关键字去访问父类构造方法。
    • c:不要为了部分功能而去继承
    • 项目经理 姓名 工号 工资 奖金
    • 程序员 姓名 工号 工资
  • B:什么时候使用继承

    • 继承其实体现的是一种关系:”is a”。
      Person
      Student
      Teacher
      水果
      苹果
      香蕉
      橘子

    采用假设法。
    如果有两个类A,B。只有他们符合A是B的一种,或者B是A的一种,就可以考虑使用继承。

08.07_面向对象(继承中成员变量的关系)(掌握)

  • A:案例演示
    • a:不同名的变量
    • b:同名的变量
      就近原则,子类中有则使用子类。一般子类继承父类就是为了使用父类的成员,那么定义同名的成员变量就没有意义了。

08.08_面向对象(this和super的区别和应用)(掌握)

  • A:this和super都代表什么
    • this:代表当前对象的引用,谁来调用我,我就代表谁
    • super:代表当前对象父类的引用
  • B:this和super的使用区别
    • a:调用成员变量
      • this.成员变量 调用本类的成员变量,也可以调用父类的成员变量
      • super.成员变量 调用父类的成员变量
    • b:调用构造方法
      • this(…) 调用本类的构造方法
      • super(…) 调用父类的构造方法
    • c:调用成员方法
      • this.成员方法 调用本类的成员方法,也可以调用父类的方法
      • super.成员方法 调用父类的成员方法
class Demo4_Extends {
    public static void main(String[] args) {
        Son s = new Son();
        s.print();
    }
}
/*
* A:案例演示
    * a:不同名的变量
    * b:同名的变量
        子父类出现同名的变量只是在讲课中举例子有,在开发中是不会出现这种情况的
        子类继承父类就是为了使用父类的成员,那么如果定义了同名的成员变量没有意义了
*/

class Father {
    int num1 = 10;
    int num2 = 30;
}

class Son extends Father {
    int num2 = 20;

    public void print() {
        System.out.println(this.num1);              //this既可以调用本类的,也可以调用父类的(本类没有的情况下)
        System.out.println(this.num2);              //就近原则,子类有就不用父类的了
        System.out.println(super.num2);
    }
}

08.09_面向对象(继承中构造方法的关系)(掌握)

  • A:案例演示
    • 子类中所有的构造方法默认都会访问父类中空参数的构造方法
  • B:为什么呢?

    • 因为子类会继承父类中的数据,可能还会使用父类的数据。
    • 所以,子类初始化之前,一定要先完成父类数据的初始化。

    • 其实:

      • 每一个构造方法的第一条语句默认都是:super() Object类最顶层的父类

08.10_面向对象(继承中构造方法的注意事项)(掌握)

  • A:案例演示
    • 父类没有无参构造方法,子类怎么办?
    • super解决
    • this解决
  • B:注意事项
    • super(…)或者this(….)必须出现在构造方法的第一条语句上
class Demo6_Extends {
    public static void main(String[] args) {
        Son s1 = new Son();
        System.out.println(s1.getName() + "..." + s1.getAge());
        System.out.println("--------------------");
        Son s2 = new Son("张三",23);
        System.out.println(s2.getName() + "..." + s2.getAge());
    }
}
/*
* A:案例演示
    * 父类没有无参构造方法,子类怎么办?
    * super解决
    * this解决
* B:注意事项
    * super(…)或者this(….)必须出现在构造方法的第一条语句上
*/
class Father {
    private String name;            //姓名
    private int age;                //年龄

    public Father() {               //空参构造
        System.out.println("Father 空参构造");
    }

    public Father(String name,int age) {    //有参构造
        this.name = name;
        this.age = age;
        System.out.println("Father 有参构造");
    }

    public void setName(String name) {  //设置姓名
        this.name = name;
    }

    public String getName() {           //获取姓名
        return name;
    }

    public void setAge(int age) {       //设置年龄
        this.age = age;
    }

    public int getAge() {               //获取年龄
        return age;
    }
}

class Son extends Father {
    public Son() {                      //空参构造
        this("王五",25);              //本类中的构造方法
        //super("李四",24);               //调用父类中的构造方法

        System.out.println("Son 空参构造");
    }

    public Son(String name,int age) {   //有参构造
        super(name,age);
        System.out.println("Son 有参构造");
    }
}

08.11_面向对象(继承中的面试题)(掌握)

  • A:案例演示
  • 看程序写结果1
    class Fu{
        public int num = 10;
        public Fu(){
            System.out.println("fu");
        }
    }
    class Zi extends Fu{
        public int num = 20;
        public Zi(){
            System.out.println("zi");
        }
        public void show(){
            int num = 30;
            System.out.println(num);
            System.out.println(this.num);
            System.out.println(super.num);
        }
    }
    class Test1_Extends {
        public static void main(String[] args) {
            Zi z = new Zi();
            z.show();
        }
    }//fu zi 30 20 18
    
    看程序写结果2
    class Fu {
        static {
            System.out.println("静态代码块Fu");
        }
    
        {
            System.out.println("构造代码块Fu");
        }
    
        public Fu() {
            System.out.println("构造方法Fu");
        }
    }
    
    class Zi extends Fu {
        static {
            System.out.println("静态代码块Zi");
        }
    
        {
            System.out.println("构造代码块Zi");
        }
    
        public Zi() {
            System.out.println("构造方法Zi");
        }
    }
    
    Zi z = new Zi(); 请执行结果。
    
解释:
class Test2_Extends {
    public static void main(String[] args) {
        Zi z = new Zi();
    }
    /*
    1,jvm调用了main方法,main进栈
    2,遇到Zi z = new Zi();会先将Fu.class和Zi.class分别加载进内存,再创建对象,当Fu.class加载进内存
    父类的静态代码块会随着Fu.class一起加载,当Zi.class加载进内存,子类的静态代码块会随着Zi.class一起加载
    第一个输出,静态代码块Fu,第二个输出静态代码块Zi
    3,走Zi类的构造方法,因为java中是分层初始化的,先初始化父类,再初始化子类,所以先走的父类构造,但是在执行
    父类构造时,发现父类有构造代码块,构造代码块是优先于构造方法执行的所以
    第三个输出构造代码块Fu,第四个输出构造方法Fu
    4,Fu类初始化结束,子类初始化,
    第五个输出的是构造代码块Zi,构造方法Zi
    */
}
class Fu {
    static {
        System.out.println("静态代码块Fu");
    }

    {
        System.out.println("构造代码块Fu");
    }

    public Fu() {
        System.out.println("构造方法Fu");
    }
}

class Zi extends Fu {
    static {
        System.out.println("静态代码块Zi");
    }

    {
        System.out.println("构造代码块Zi");
    }

    public Zi() {
        System.out.println("构造方法Zi");
    }
}

08.12_面向对象(继承中成员方法关系)(掌握)

  • A:案例演示
    • a:不同名的方法
    • b:同名的方法

08.13_面向对象(方法重写概述及其应用)(掌握)

  • A:什么是方法重写
    • 重写:子父类出现了一模一样的方法(注意:返回值类型可以是子父类,这个我们学完面向对象讲)
  • B:方法重写的应用:
    • 当子类需要父类的功能,而功能主体子类有自己特有内容时,可以重写父类中的方法。这样,即沿袭了父类的功能,又定义了子类特有的内容。
  • C:案例演示
    • a:定义一个手机类。

08.14_面向对象(方法重写的注意事项)(掌握)

  • A:方法重写注意事项

    • a:父类中私有方法不能被重写
      • 因为父类私有方法子类根本就无法继承
    • b:子类重写父类方法时,访问权限不能更低
      • 最好就一致
    • c:父类静态方法,子类也必须通过静态方法进行重写

      • 其实这个算不上方法重写,但是现象确实如此,至于为什么算不上方法重写,多态中我会讲解(静态只能覆盖静态)
    • 子类重写父类方法的时候,最好声明一模一样。

  • B:案例演示
    • 方法重写注意事项

08.15_面向对象(方法重写的面试题)(掌握)

  • A:方法重写的面试题

    • Override和Overload的区别?Overload能改变返回值类型吗?
    • overload可以改变返回值类型,只看参数列表
    • 方法重写:子类中出现了和父类中方法声明一模一样的方法。与返回值类型有关,返回值是一致(或者是子父类)的

    • 方法重载:本类中出现的方法名一样,参数列表不同的方法。与返回值类型无关。

    • 子类对象调用方法的时候:

      • 先找子类本身,再找父类。

08.16_面向对象(使用继承前的学生和老师案例)(掌握)

  • A:案例演示
    • 使用继承前的学生和老师案例
    • 属性:姓名,年龄
    • 行为:吃饭
    • 老师有特有的方法:讲课
    • 学生有特有的方法:学习

08.17_面向对象(使用继承后的学生和老师案例)(掌握)

  • A:案例演示
    • 使用继承后的学生和老师案例

08.18_面向对象(猫狗案例分析,实现及测试)(掌握)

  • A:猫狗案例分析
  • B:案例演示
    • 猫狗案例继承版
    • 属性:毛的颜色,腿的个数
    • 行为:吃饭
    • 猫特有行为:抓老鼠catchMouse
    • 狗特有行为:看家lookHome

08.19_面向对象(final关键字修饰类,方法以及变量的特点)(掌握)

  • A:final概述
  • B:final修饰特点
    • 修饰类,类不能被继承
    • 修饰变量,变量就变成了常量,只能被赋值一次
    • 修饰方法,方法不能被重写
  • C:案例演示
    • final修饰特点

08.20_面向对象(final关键字修饰局部变量)(掌握)

  • A:案例演示

    • 方法内部或者方法声明上都演示一下(了解)

    • 基本类型,是值不能被改变

    • 引用类型,是地址值不能被改变,对象中的属性可以改变

08.21_面向对象(final修饰变量的初始化时机)(掌握)

  • A:final修饰变量的初始化时机
    • 显示初始化
    • 在对象构造完毕前即可
      注:成员变量的默认初始化值是无效的。

08.22_day08总结

  • 把今天的知识点总结一遍。
0
0
查看评论

面向对象编程三大特性------封装、继承、多态

本文是对面向对象编程三大特性(封装、继承、多态)的一个学习总结。 封装隐藏了类的内部实现机制,可以在不影响使用的情况下改变类的内部结构,同时也保护了数据。对外界而已它的内部细节是隐藏的,暴露给外界的只是它的访问方法。 继承是为了重用父类代码。两个类若存在IS-A的关系就可以使用继承。,同时继承也为实...
  • jianyuerensheng
  • jianyuerensheng
  • 2016-06-07 11:41
  • 8710

面向对象_继承案例和继承的好处与继承的弊端

/* 继承概述: 把多个类中相同的内容给提取出来定义到一个类中。 如何实现继承呢? java提供了关键字:extends 格多: //class 子类名,派生类名 extends 父类名,基类名,超类名 {} class 子类名 extdens 父类名 {} 好处: A:提高了代码的复用性。 ...
  • L1585931143
  • L1585931143
  • 2016-09-26 22:13
  • 1012

java-面向对象编程-三大特性之继承

面向对象的编程语言,拥有三大特性,分别是:“继承”,“多态”,“封装”。这三个特性贯穿了面向对象编程语言的方方面面,也是区别于面向过程语言的三个标志。所以,掌握这三个特性,将有助于你在学习面向对象编程方面取得更好的进步。或者你现在学的是java,以后你又想学其他的面向对象编程语言的时候,也能帮助你更...
  • dengminghli
  • dengminghli
  • 2017-01-15 21:36
  • 1346

【Python学习笔记】面向对象编程:继承和多态

【根据廖雪峰python教程整理】 一、继承 在OOP程序设计中,当我们定义一个class的时候,可以从某个现有的class继承,新的class称为子类(Subclass),而被继承的class称为基类、父类或超类(Base class、Super class)。  ...
  • Junkichan
  • Junkichan
  • 2016-07-11 15:14
  • 803

继承与派生(面向对象)

1.继承与派生的概念:在C++中,所谓“继承”就是在一个已存在的类的基础上建立一个新的类。已存在的类称为“基类(base class)”或“父类(father class)”,新建的类称为“派生类(derived class)”或“子类(son class )”。一个新类从已有的类那里获得其已有特性...
  • Huangweilan
  • Huangweilan
  • 2016-10-27 14:47
  • 223

JavaScript面向对象编程(继承实现方式)

许多OO 语言都支持两种继承方式:接口继承和实现继承。接口继承只继承方法签名,而实现继承则继承实际的方法。如前所述,由于函数没有签名,在ECMAScript 中无法实现接口继承。ECMAScript 只支持实现继承,而且其实现继承主要是依靠原型链来实现的。在此,主要阐述...
  • hsd2012
  • hsd2012
  • 2016-03-25 15:10
  • 613

JavaScript(面向对象+原型理解+继承+作用域链和闭包+this使用总结)

JavaScript(面向对象+原型理解+继承+作用域链和闭包+this使用总结) 一、面向对象 1、什么是面向对象 ☞ 面向对象就是把构成问题事物分解成多个对象,建立对象不是为了完成某个步骤,而是描述某个事物在这个解决问题的步骤中的行为。 1.面向对象是一种思维方法 2.面向对象...
  • Monster_man
  • Monster_man
  • 2017-08-21 19:22
  • 2602

深入javascript面向对象,js的原型链、继承

进阶面向对象——————————————————————–在JS源码中,系统对象也是基于原型的程序, 尽量不要去添加和修改系统对象的方法 包装对象——————————————————————–基本类型都有自己对应的包装对象 比如String Number Boolean 基本类型会找到对应的包装对象...
  • u014420383
  • u014420383
  • 2015-08-15 08:57
  • 1258

Java面向对象:封装、继承、多态

为什么要面向对象编程? 以前开发的过程通常是采用面向过程编程,面向过程是以过程为中心来进行编程设计,本质上是分析出需要哪些过程,在编程时一步步的对其实现,但是随着软件规模的扩大,这种面向过程的设计模式已经越来越不适应如此大规模的软件。面向过程存在着诸多的缺点比如:     1.软...
  • wangyang1354
  • wangyang1354
  • 2015-09-30 16:44
  • 1215

面向对象继承中内存加载原理

开始JVM里面会有两个类 一个是 zi.class ,和Fu.class    1.运行到zi的构造函数的时候。会在第一样运行super()调用父类构造函数。那么我们就加载父类的代码块。  2.现有类我们才能创建new对象, 这样才会在堆里面开辟一块空间。  ...
  • heisedelangzi
  • heisedelangzi
  • 2015-07-01 10:45
  • 533
    个人资料
    • 访问:108074次
    • 积分:2632
    • 等级:
    • 排名:第16320名
    • 原创:160篇
    • 转载:10篇
    • 译文:0篇
    • 评论:4条
    最新评论