CoreJava 笔记总结-第五章 继承

于 2021-08-28 21:02:24 发布
阅读量674 收藏
点赞数 1
分类专栏： java 文章标签： java intellij-idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_53051556/article/details/119973144
版权

文章目录

第五章 继承

类、超类和子类

定义子类

  • extend: 该关键字表示继承
public class Manager extends Employee // java中所有的继承都是公共继承
{
    added methods and fields
}
  • extend: 表示正在构造的类派生于一个已存在的类.这个已存在的类称为超类(基类,父类). 新类称为子类(派生类, 孩子类)
  • 子类比超类拥有更多的功能
  • 设计类: 最一般的类放在超类中, 更特殊的方法放入子类

覆盖方法

  • super: 调用超类方法

    public class Manager extends Employee
{
    public double getSalary(){
		double baseSalary = super.getSalary();
        return baseSalary + bonus;
    }
}

子类构造器

  • 由于Manager构造器不能访问Emplyee类的私有字段, 所以通过super来调用初始化这些私有字段

    public Manager(String name, double salary, int year, int month, int day)
{
    super(name, salary, year, month, day);//必须放在第一句
    bonus = 0;
}

  • this: 1. 隐式参数的引用 2. 调用该类的其他构造器

    super: 1. 调用其他超类的方法 2. 调用超类的构造器

多态

  • 多态: 一个变量能够指示多种实际类型的现象
Manager boss = new Manager(...)
Employee[] staff = new Employee[3];
staff[0] = boss;
  • 上面的例子中boss, staff[0]指示同一个对象, 但是编译器只将staff[0]看成一个Emplyee对象
  • 子类引用的数组可以转换成超类引用的数组
Manager[] managers = new Manager[10];
Employee[] staff = managers;
  • 重载解析: 选择所有名字相同的方法中存在一个与提供参数完全相匹配的方法
  • 签名: 方法的名字和参数列表. 返回类型不是签名的一部分
  • 在覆盖一个方法时,子类方法不能低于超类方法的可见性.e.g.: 超类为public, 子类也必须为public

阻止继承: final类和方法

  • final类: 不允许扩展的类, 其中的方法自动设置成为fianl方法, 不包括字段
  • final方法: 子类不能覆盖的方法
  • fianl字段: 构造对象后就不允许改变其值

强制类型转换

  • Manager boss = (Manager) staff[0];

  • Manager boss = (Manager) staff[1]; // ERROR 抛出异常: ClassCastException

  • if (staff[1] instanceof Manager){
    boss = (Manager) staff[1];
    ....
}//查看能否强制类型转换成功

  • 继承层次: 由一个公共类派生出来所有类的集合

    1. 只能在继承层次类进行强制类型转换
    2. 在将超类强制类型转换为子类之前, 应该用instanceof进行检查

抽象类

  • 位于上层的类更具有一般性,更加抽象

  • 包含一个及以上抽象方法的类必须声明为抽象类

  • public abstract class Person
{
    ...
    public abstract String getDescription();
}

  • 抽象类也可以包含字段和具体方法

  • 抽象类不能实例化. new Person("dvsj"); //ERROR

  • 可以定义一个抽象类的对象变量, 引用非抽象子类的对象

Person p = new Student("Alice");

package chapter5_inheritance.abstruct_classes;

public abstract class Person {//抽象类
    public abstract String getDescription();//抽象方法

    private String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {//抽象类中也可以由方法
        return name;
    }
}


package chapter5_inheritance.abstruct_classes;


public class Student extends Person {
    private String major;

    /**
     * @param name  the student's name
     * @param major the student's major
     */

    public Student(String name, String major) {
        super(name); // 继承Person
        this.major = major;//隐式参数的引用
    }

    public String getDescription() { // 对应抽象类中的抽象方法
        return "A student major in " + major;
    }
}

package chapter5_inheritance.abstruct_classes;

import java.time.LocalDate;

public class Employee extends Person
{

    private double salary;
    private LocalDate hireDay;

    public Employee(String name, double salary, int year, int month, int day) {
        super(name);
        this.salary = salary;
        hireDay = LocalDate.of(year, month, day);
    }

    public double getSalary() {
        return salary;
    }

    public LocalDate getHireDay() {
        return hireDay;
    }

    public void raiseSalary(double byPercent) {
        double delta = salary * byPercent / 100;
        salary += delta;
    }

    public String getDescription() {
        return String.format("An employee with a salary of %.2f", salary);
    }
}


package chapter5_inheritance.abstruct_classes;

public class Person_test {

    public static void main(String[] args) {
        /* 声明为Person类型 */
        var people = new Person[2];
        /* 每一个Person类型的people[i] 声明为对应子类类型 */
        people[0] = new Student("oukunnan", "Software Engineering");
        people[1] = new Employee("vfjh", 1500.0, 1259, 5, 12);
        /* 注意点 类型 参数： 实参数组 */
        for (Person p : people) {
            System.out.println(p.getName() + ", " + p.getDescription());
        }
    }
}

受保护访问

  • protected: 限制超类中某个方法只允许子类访问, 希望允许子类的方法访问超类的某个字段
  • 保护字段只能由同一个包中的类访问

访问控制修饰符小结

  1. private: 仅对本类可见
  2. public: 对外部完全可见
  3. protected: 对本包和所有子类可见
  4. 无: 对本包可见, 不需要修饰符

Object: 所有类的超类

Object类型的变量

  • 可以使用object类型的变量引用任何类型的对象
Object obj = new Employee("sbjd", 2000);
  • 只能作为各种值的一个泛型容器, 进行具体操作需要强制类型转换
Employee e = (Employee)obj;
  • 只有基本类型不是对象: 数值, 字符, 布尔类型的值

equals方法

  • 该方法确定两个对象的引用是否相等
public boolean equals(Object otherObject) {

    if (this == otherObject) {
        return true;
    }//判引用
    if (otherObject == null) {
        return false;
    }//判空
    if (getClass() != otherObject.getClass()) {
        return false;
    }//判对象所属类是否相等
    Employee other = (Employee) otherObject;
	//调用Object.equals()而不是name.equals(other.name)为了防备name, hireDay为null情况
    return Objects.equals(name, other.name) && salary == other.salary
        && Objects.equals(hireDay, other.hireDay);
}
  • 子类中: if(!super.equals(otherObject)) return false; ...

相等测试与继承

  • equals方法要求: 自反性, 对称性, 传递性, 一致性
  • 比较数组元素是否相等, 使用静态方法Arrays.equals
  • @Override标记要覆盖超类的那些子类方法

hashCode方法

  • 散列码: 值由对象的储存地址得出
  • 字符串的散列码时由内容导出的
  • Object.hasCode: null安全的方法
  • Object.hash():组合多个散列值, 这个方法对于各个参数调用Object.hasCode()
  • Arrays.hashCode:数组类型字段计算散列码
  • hasCode, equals方法必须兼容

toString方法

  • x.toString() 等价于 "" + x
  • System.out.println(x)会自动调用x.toString()
  • 对于数组: Arrays.toString, Arrays.deepToString

泛型数组列表

  • ArrayList类: 类似于数组, 在添加或者删除数组元素时可以自动调整数组容量
  • 它是一个有类型参数的泛型类

声明数组列表

  • 以下三种声明方式等价
ArrayList<Employee> staff = new ArrayList<Employee>();
ArrayList<Employee> staff = new ArrayList<>(); // 菱形语法
var staff = new ArrayList<Employee>();
  • add: 将元素添加到列表中
  • ensureCapacity: 确保数组列表在不重新分配内部储存数组的情况下有足够容量储存给定数量的元素
  • trimToSize: 将数组列表的存储容量消减到当前大小
  • size: staff.size() 等价于数组的a.length, 表示实际包含元素个数

访问数组列表元素

  • get: 得到指定索引位置的值
  • set: 重新设置索引位置已经存在的值
  • add(int index, E obj):后移元素从而插入obj到指定位置
  • remov(int index): 删除指定索引位置的元素, 后面的元素前移
  • toArray: 将数组元素拷贝到一个数组中
list.toArray(a); //将数组列表list中的元素拷贝到数组a中

类型化与原始数组列表的兼容性

  • public class EmployeeDB
{
    public void update(ArrayList list){...}
    public ArrayList find(String query) {...}

  • 可以将类型化的数组列表传递给update, 不需要强制类型转换

  • 但是原始ArrayList赋给类型化ArrayList会有警告, 强制类型转换也不可以消除警告,会引发类型转换有误的另一个警告

  • @SuppressWarning("unchecked") ArrayList<Employee> result = (ArrayList<Employee>) emplyeeDB.find(x);

  • 用以上注解标记问题不太严重的强制类型转换的变量

对象包装器与自动装箱

  • 包装器: 所有的基本类型对应的类(Integer, Double, Long, Float, Short, Byte, Character, Boolean)

  • 包装器类是final, 不能派生子类

  • 尖括号中的类型参数不允许是基本类型, 可以这样var list = new ArrayList<Integer>();

  • 自动装箱:

    list.add(3) --> list.add(Integer.valueOf(3))

  • 自动拆箱:

int n = list.get(i); --> list.get(i).intValue();

  • Integer a = 1000;
Integer b = 1000;
if (a == b) ..//通常失败

    ==运算符比较的是对象是否占有相同的内存位置

  • -128~127之间的short, int被包装到固定的对象中, 上面的比较就会成功

参数数量可变的方法

  • ...: 是Java代码的一部分, 表示这个方法可以接受任意数量的对象

    public class PrintStream
{
    public PrintStream printf(String fmt, Object... args){return format(fmt, args);}
}

  • printf方法接受两个参数, 一个是格式化字符串, 另一个是Object[]数组, 其中保存着所有其他参数(整数或者其他基本类型的值会自动装箱为对象), Object...参数类型和Object[]完全一样

枚举类

  • public enum Size { SMALL, MEDIUM, LARGE, EXTRA_LARG};
  • 枚举构造器总是私有的
  • 所有枚举类型都是Enum的子类
  • values: 返回一个包含全部枚举值的数组

反射

  • 反射: 能够分析类能力的程序

Class类

  • getClass: 返回类的名字
  • forName: 获得类名对应的Class对象
  • T.class: 代表匹配的类对象
  • Class实际上是泛型类, Employee.class-->Class<Employee>

声明异常入门

  • 处理器处理抛出的异常
  • 异常分为
    1. 非检查型异常
    2. 检查型异常

利用反射分析类的能力

  • java.lang.reflect包中有三个类Field, Method, Constructor分别用于描述类的字段,方法和构造器, 这三个类都有一个gteName方法, 返回其名称
  • Class类中的getFields, getMethods, getConstructors 方法返回这个类支持的公共字段,方法和构造器的数组, 其中包括超类的公共成员
  • Class类中的getDeclaredFields, getDeclareMethods, getDeclaredConstructors 方法返回这个类声明的全部字段,方法和构造器,包括私有成员,包成员,受保护成员,不包括超类成员
package chapter5_inheritance;

import java.util.*;
import java.lang.reflect.*;

public class reflection {

    public static void main(String[] args)
            throws ReflectiveOperationException
    {
        // read class name from command line args or user input
        String name;
        if (args.length > 0) name = args[0];
        else
        {
            var in = new Scanner(System.in);
            System.out.println("Enter class name (e.g. java.util.Date): ");
            name = in.next();
        }

        // print class name and superclass name (if != Object)
        Class cl = Class.forName(name);
        Class supercl = cl.getSuperclass();
        String modifiers = Modifier.toString(cl.getModifiers());
        if (modifiers.length() > 0) System.out.print(modifiers + " ");
        System.out.print("class " + name);
        if (supercl != null && supercl != Object.class) System.out.print(" extends "
                + supercl.getName());

        System.out.print("\n{\n");
        printConstructors(cl);
        System.out.println();
        printMethods(cl);
        System.out.println();
        printFields(cl);
        System.out.println("}");
    }

    /**
     * Prints all constructors of a class
     * @param cl a class
     */
    public static void printConstructors(Class cl)
    {
        Constructor[] constructors = cl.getDeclaredConstructors();

        for (Constructor c : constructors)
        {
            String name = c.getName();
            System.out.print("   ");
            String modifiers = Modifier.toString(c.getModifiers());
            if (modifiers.length() > 0) System.out.print(modifiers + " ");
            System.out.print(name + "(");

            // print parameter types
            Class[] paramTypes = c.getParameterTypes();
            for (int j = 0; j < paramTypes.length; j++)
            {
                if (j > 0) System.out.print(", ");
                System.out.print(paramTypes[j].getName());
            }
            System.out.println(");");
        }
    }

    /**
     * Prints all methods of a class
     * @param cl a class
     */
    public static void printMethods(Class cl)
    {
        Method[] methods = cl.getDeclaredMethods();

        for (Method m : methods)
        {
            Class retType = m.getReturnType();
            String name = m.getName();

            System.out.print("   ");
            // print modifiers, return type and method name
            String modifiers = Modifier.toString(m.getModifiers());
            if (modifiers.length() > 0) System.out.print(modifiers + " ");
            System.out.print(retType.getName() + " " + name + "(");

            // print parameter types
            Class[] paramTypes = m.getParameterTypes();
            for (int j = 0; j < paramTypes.length; j++)
            {
                if (j > 0) System.out.print(", ");
                System.out.print(paramTypes[j].getName());
            }
            System.out.println(");");
        }
    }

    /**
     * Prints all fields of a class
     * @param cl a class
     */
    public static void printFields(Class cl)
    {
        Field[] fields = cl.getDeclaredFields();

        for (Field f : fields)
        {
            Class type = f.getType();
            String name = f.getName();
            System.out.print("   ");
            String modifiers = Modifier.toString(f.getModifiers());
            if (modifiers.length() > 0) System.out.print(modifiers + " ");
            System.out.println(type.getName() + " " + name + ";");
        }
    }
}

/*
Enter class name (e.g. java.util.Date): 
java.lang.Double
public final class java.lang.Double extends java.lang.Number
{
   public java.lang.Double(double);
   public java.lang.Double(java.lang.String);

   public boolean equals(java.lang.Object);
   public static java.lang.String toString(double);
   public java.lang.String toString();
   public int hashCode();
   public static int hashCode(double);
   public static double min(double, double);
   public static double max(double, double);
   public static native long doubleToRawLongBits(double);
   public static long doubleToLongBits(double);
   public static native double longBitsToDouble(long);
   public volatile int compareTo(java.lang.Object);
   public int compareTo(java.lang.Double);
   public byte byteValue();
   public short shortValue();
   public int intValue();
   public long longValue();
   public float floatValue();
   public double doubleValue();
   public static java.lang.Double valueOf(java.lang.String);
   public static java.lang.Double valueOf(double);
   public static java.lang.String toHexString(double);
   public static int compare(double, double);
   public static boolean isNaN(double);
   public boolean isNaN();
   public static boolean isInfinite(double);
   public boolean isInfinite();
   public static boolean isFinite(double);
   public static double sum(double, double);
   public static double parseDouble(java.lang.String);

   public static final double POSITIVE_INFINITY;
   public static final double NEGATIVE_INFINITY;
   public static final double NaN;
   public static final double MAX_VALUE;
   public static final double MIN_NORMAL;
   public static final double MIN_VALUE;
   public static final int MAX_EXPONENT;
   public static final int MIN_EXPONENT;
   public static final int SIZE;
   public static final int BYTES;
   public static final java.lang.Class TYPE;
   private final double value;
   private static final long serialVersionUID;
}
*/

继承的设计技巧

  1. 将公共操作和字段放在超类中
  2. 不要使用受保护的字段
  3. 使用继承实现"is-a"关系
  4. 除非所有继承方法都有意义, 否则不要使用继承
  5. 在覆盖方法时,不要改变预期的行为
  6. 使用多态, 而不要使用类型信息
  7. 不要滥用反射
类型化与原始数组列表的兼容性
Got_Goal的专栏
08-14 1957
类型化与原始数组列表的兼容性
Java学习day031 泛型数组列表（访问数组列表元素、类型化与原始数组列表的兼容性）
Zzehao的博客
04-03 424
使用的教材是java核心技术卷1，我将跟着这本书的章节同时配合视频资源来进行学习基础java知识。 day031 泛型数组列表 在许多程序设计语言中，特别是在C++语言中，必须在编译时就确定整个数组的大小。程序员对此十分反感，因为这样做将迫使程序员做出一些不情愿的折中。例如，在一个部门中有多少雇员？肯定不会超过100人。一旦出现一个拥有150名雇员的大型部门呢？愿意为那些仅有10名雇员的部...
泛型数组列表（ArryList）
enen.....博客
06-03 1097
泛型数组列表（ArryList）： 初识编程语言就是c语言。而在c语言中，对于数组大小的判断，必须在编译的时候就确定，对此感觉 十分的苦恼，毕竟某大型公司中的大型部门，是不愿意为那些仅仅有10名的雇员的部门浪费90 名雇员占据的办公室的。 而在Java中，就允许在运行是才确定数组的大小。 int size=...; Employee[] staff = new Employee[si...
Java核心技术 继承2
花开不合阳春暮
11-13 187
3.泛型数组列表 一旦确定了数组的大小，改变它就不太容易。在Java中解决这个问题最简单的方法是使用Java中另一个被称为ArrayList的类，在添加和删除元素时，具有自动调节数组容量的功能。 ArrayList是一个采用了类型参数（type parameter）的泛型类（generic class）。 ArrayList<Employee> staff = new ArrayLis...
再谈JAVA
V2636011127的博客
02-18 241
泛型数组列表 在JAVA中允许存在在运行时改变数组的大小。但是一旦确定数组大小很难改变。使用ArrayList的类，具有删除和添加的功能，不需要为此编写任何代码。 ArrayList是一个采用类型参数的泛型类。为了指定数组列表保存的元素类型，需要用一对尖括号将类名括起来，加在后面如ArrayList<Employee> 如果在菱形中赋值变量、方法或者某个方法的返回。编译器都会将这个变量...
Java CoreJava笔记：第11天探讨集合框架与接口实现
在Core Java Day 11的学习笔记中，主要探讨了Java集合框架（Collection Framework）的概念和关键接口。集合是Java编程中一个重要的概念，用于存储和管理对象的容器，它为各种类型的有序或无序、可重复或不可重复的...
corejava部分笔记总结
11-20
### CoreJava基础知识精要 #### 一、面向过程与面向对象编程思维的转变 在计算机编程领域，程序设计模式主要有两种：面向过程编程和面向对象编程。这两种编程思想决定了程序的构建方式及其组织形式。 **面向过程...
java\CoreJava笔记\CoreJAVA_day01
08-25
CoreJava是Java的基础，涵盖了Java Standard Edition (J2SE)的主要内容，包括基本语法、面向对象编程（OO）原则、核心类库的使用等。在学习CoreJava时，我们需要掌握以下几个关键知识点： 1. **编程思想**： - ...
CoreJava笔记
09-23
《CoreJava笔记》是针对Java编程初学者及进阶者的一份宝贵资料，它涵盖了Core Java的核心概念和技术，旨在帮助读者深入理解并掌握这门强大的编程语言。在本笔记中，我们将探讨Java语言的基础，包括语法、面向对象...
Corejava 核心java笔记
12-22
这份名为"Corejava 核心java笔记"的资料应该包含了作者在学习Java基础时的一些理解和实践心得，对于初学者来说是一份宝贵的参考资料。 1. **Java语法**: Java语法简洁而严谨，包括变量声明、数据类型（如整型、浮点...
类型兼容性原则
RitaAndWakaka的博客
04-06 504
#include&lt;iostream&gt;//31 #include&lt;cstdlib&gt; using namespace std; //类型兼容性原则 class Parent { public: void printP() { cout &lt;&lt; "我是爹..." &lt;&lt; endl; } Parent() { cout &lt;&lt; "p.
类型化数组
weixin_33714884的博客
10-17 282
类型化数组是javascript操作(内存)二进制数据的一个接口。 类型化数组是建立在ArrayBuffer对象的基础上的。它的作用是，分配一段可以存放数据的连续内存区域。 var buf = new ArrayBuffer(32); //生成一段32字节的内存区域，即变量buf在内存中占了32字节大小 ArrayBuffer对象的byteLength属性，返回所分配的内存区域的字节长度...
《Java核心技术 卷I》学习笔记19：泛型数组列表
qq_48814205的博客
01-09 302
Java泛型数组列表：ArrayList
JAVA--泛型数组列表(允许在运行时确定数组的大小)
Mikowoo007的博客
07-31 831
ArrayList 是一个采用 类型参数(type parameter) 的 泛型类(generic class) import java.util.*; ArrayList<Employee> staff = new ArrayList<>(); import java.util.*; public class ArrayListTest { public s...
JAVA学习笔记——面向对象编程：继承2
weixin_43410001的博客
04-08 301
本文针对继承方面的一些零散知识点进行梳理，具体继承相关的知识，请参考这篇文章《JAVA学习笔记——面向对象编程：继承1》。 目录泛型数组列表访问数组列表元素类型化与原始数组列表的兼容性对象包装器与自动装箱可变参数的方法继承的设计技巧 泛型数组列表 ArrayList 是一个采用类型参数 (type parameter) 的泛型类 (generic class)。它使用起来有点像数组，但在添加或删除元素时，具有自动调节数组容量的功能，而不需要为此编写任何代码。 为了指定数组列表保存的元素对象类型，需要用一.
泛型数组列表ArrayList
PacosonSWJTU的博客
11-09 913
【0】README0.1） 本文描述+源代码均 转自 core java volume 1， 旨在理清 java 中的 数组列表 ArrayList； 【2】数组列表 ArrayList2.1）ArrayList： ArrayList 具有自动调节数组容量的功能， 而不需要为此编写任何代码； 2.2）ArrayList 是一个采用类型参数的泛型类： ArrayList staff =new Arr
阅读Java核心技术Ⅰ的笔记（Java基础、第五章、继承）
阿兰你在哪
07-21 276
Java核心技术Ⅰ第五章5.1 类、超类和子类5.1.1 定义子类5.1.2 覆盖方法5.1.3 子类构造器5.1.4 继承层次5.1.5 多态5.1.6 理解方法调用5.1.7 阻止继承：final类和方法5.1.8 强制类型转换5.1.9 抽象类5.1.10 受保护访问5.2 Object:所有类的超类5.2.1 equals方法5.2.2 相等测试与继承5.2.3 hashCode方法5.2.4 toString方法5.3 泛型数组列表5.3.1 访问数组列表元素5.3.2 类型化与原始数组列表的兼容
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

风起风里

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值