0.写在前面

  1. 本笔记用作复习查看用，基础完整总结部分，基础不牢，地动山摇！ | 🔥Java帝国之行🔥 | 地址 | | —- | —- | | Java核心编程总结（一、继承） 🔥 | https://blog.csdn.net/Augenstern_QXL/article/details/116209463 | | Java核心编程总结（二、抽象类与接口）🔥 | https://blog.csdn.net/Augenstern_QXL/article/details/116209487 | | Java核心编程总结（三、多态与内部类）🔥 | https://blog.csdn.net/Augenstern_QXL/article/details/116209507 | | Java核心编程总结（四、异常与线程） 🔥 | https://blog.csdn.net/Augenstern_QXL/article/details/116209529 | | Java核心编程总结（五、线程池与死锁）🔥 | https://blog.csdn.net/Augenstern_QXL/article/details/116209580 | | Java核心编程总结（六、常用API与集合）🔥 | https://blog.csdn.net/Augenstern_QXL/article/details/116209607 | | Java核心编程总结（七、Stream流）🔥 | https://blog.csdn.net/Augenstern_QXL/article/details/116209624 | | Java核心编程总结（八、IO输入输出流）🔥 | https://blog.csdn.net/Augenstern_QXL/article/details/116209648 | | Java核心编程总结（九、File文件类）🔥 | https://blog.csdn.net/Augenstern_QXL/article/details/116209674 | | Java核心编程总结(十、反射) 🔥 | https://blog.csdn.net/Augenstern_QXL/article/details/117744497 |

1. 基础回顾+面试

1.1 类中成分

  1. 成员变量(Field:描述类和对象的属性信息的)
  2. 成员方法(Methpd:描述类或者对象的行为信息的)：包括实例方法，静态方法，抽象方法，getter setter 方法
  3. 构造器(Constructor:初始化一个类的对象并返回引用)
    • 默认无参构造器：一个类默认会自带一个无参构造器，即使不写它也存在，但是如果一个类它写了一个构造器，那么默认的无参构造器就被覆盖了！
    • 有参构造器
  4. 代码块
  5. 内部类 ```java / javaBean类: 封装数据 / public class Student { // 两个成员变量 私有 private String name; private int age;
  1. // 无参构造器
  2. public Student(){
  4. }
  7. // 有参数构造器
  8. public Student(String name,int age){
  9.     this.name = name;
  10.     this.age = age;
  11. }
  12. // 成员方法: setXX \ gerXX
  13. public void setName(String name){
  14.     this.name = name;        
  15. }
  16. public String getName(){
  17.     return name;
  18. }
  20. public void setAge(int age){
  21.     this.age = age
  22. }
  23. public int getAge(){
  24.     return age;
  25. }
  26. public void show(){
  27.     System.out.print;n(name + "..." + age);
  28. }

}

  1. <a name="gh1CV"></a>
  2. ## 1.2 this关键字
  4. - `this`关键字可以用在**实例方法和构造器中**
  5.    - `this`关键字用在方法中，谁调用这个方法，`this`就代表谁
  6.    - `this`关键字用在构造器上，代表了构造器正在初始化那个对象的引用
  7. ```java
  8. /*
  9.    javaBean类: 封装数据
  10. */
  11. public class Student {
  12.     // 两个成员变量 私有
  13.     private String name;
  14.     private int age;
  16.     // 无参构造器
  17.     public Student(){
  19.     }
  21.     // 有参数构造器中可以用 this 关键字
  22.     public Student(String name,int age){
  23.         this.name = name;
  24.         this.age = age;
  25.     }
  26.     // 实例方法中可以用 this 关键字
  27.     // 成员方法: setXX \ gerXX
  28.     public void setName(String name){
  29.         this.name = name;        
  30.     }
  31.     public String getName(){
  32.         return name;
  33.     }
  34.     public void setAge(int age){
  35.         this.age = age
  36.     }
  37.     public int getAge(){
  38.         return age;
  39.     }
  40.     public void show(){
  41.         System.out.print;n(name + "..." + age);
  42.     }
  43. }

1.3 static关键字

– 按照有无static修饰，成员变量和方法可以分为

  1. 成员变量
    1. 静态成员变量(类变量)
      有static修饰的成员变量称为静态成员变量，也叫类变量，属于类本身，直接用类名访问即可
    2. 实例成员变量
      无static修饰的成员变量称为实例成员变量，属于类的每个对象的，必须用类的对象来访问
  2. 成员方法
    1. 静态方法
      有static修饰的成员方法称为静态方法，也叫类方法，属于类本身的，直接用类名访问即可
    2. 实例方法
      无static修饰的成员方法称为实例方法，属于类的每个对象的，必须用类的对象来访问

  3. 成员变量的访问语法

    1. 静态成员变量访问：
      • 类名.静态成员变量
      • 对象.静态成员变量（也可以访问，但是不推荐）

    2. 实例成员变量的访问：

      • 对象.实例成员变量 ```java public class Student { // 1.静态成员变量: 有static修饰，属于类本身，直接用类名访问即可！ public static String schoolName = “中国”; // 2.实例成员变量: 无static修饰，属于类的对象，必须用对象访问 private String name; private int age;

      public static void main(String[] args){ // 1.类名.静态成员变量 System.out.println(Student.schoolName);//中国 // 注意:同一个类中访问静态成员变量可以省略类名不写 System.out.println(schoolName);//中国

      // 2.对象.实例成员变量 Student s1 = new Student(); s1.name = “孙悟空”; System.out.println(s1.name);//孙悟空

      // 3.对象.静态成员变量(不推荐) System.out.println(s1.schoolName);//中国 // 静态成员变量属于类，直接用类名访问即可 } } ```

      1.4 继承的概述

  • 继承是子类到父类的一种关系
  • 子类继承了一个父类，子类就可以直接得到父类的属性（成员变量）和行为（方法）了
  • 在java中继承是 “is a” 的关系。Cat extends Animal : 猫是一个动物
  • 在java中，子类是更强大的，子类不仅继承了父类的功能，自己还可以定义自己的功能

格式：

  1. 子类 extends 父类 {
  3. }

1.5 子类不能继承父类的内容

  • 子类继承父类，子类就得到了父类的属性和行为，但是并非所有父类的属性和行为等子类都可以继承
  • 子类不能继承父类的构造器，只能调用：子类有自己的构造器(没有争议) ```java public class ExtendsDemo { public static void main(String[] args) {
    1.   // Cat c = new Cat();
    }

class Cat extends Animal{

} class Animal{ // 父类中的静态成员方法 private void run(){

  1.     }

}

  1. <a name="6xlLA"></a>
  2. ## 1.6 继承后成员变量的访问特点
  3. **就近原则：子类有就找子类，子类没有找父类，父类没有就报错！**
  5. - `this` 代表了当前对象的引用，可以用于访问当前子类对象的成员变量
  6. - `super` 代表了父类对象的引用，可以用于访问父类中的成员变量
  7. ```java
  8. public class TestDemo {
  9.     public static void main(String[] args) {
  10.         Cat cat = new Cat();
  11.         cat.show();
  12.     }
  13. }
  14. class Animal{
  15.     public String name = "动物名称";
  16. }
  18. class Cat extends  Animal {
  19.     public String name = "子类名称";
  20.     public void show() {
  21.         String name = "局部名称";
  22.         System.out.println(name);  //局部名称
  23.         System.out.println(this.name);  //子类名称
  24.         System.out.println(super.name); //父类名称
  25.     }
  26. }

1.7 继承后成员方法的访问特点

  • 子类对象优先使用子类已有的方法

    1.8 继承后方法重写

  • java建议在重写的方法上面加一个@override 注解

  • 方法一旦加了这个@override 注解，那就必须是成功重写父类的方法，否则报错！

方法重写的规范：

  1. 子类重写方法的名称和形参列表必须与父类被重写方法一样
  2. 子类重写方法的返回值类型声明要么与父亲一样，要么比父类方法返回值类型范围更小
  3. 子类重写方法的修饰符权限应该与父类被重写方法的修饰符权限相同或者范围更大
  4. 子类重写方法申明抛出的异常应该与父类被重写方法申明抛出的异常一样或者范围更小

小结：

  1. 方法重写是子类重写一个与父类申明一样的方法覆盖父类的方法
  2. 方法重写要加@override 注解
  3. 方法重写的核心要求：方法名称，参数列表必须与被重写方法一致！

扩展：

  • 静态方法和私有方法是否可以被重写？

答：都不可以，加上@override会报错

1.9 继承后构造器特点

  • 子类继承父类，子类的全部构造器默认会先访问父类的无参构造器，再执行子类自己的构造器
  1. 为什么子类的构造器会先调用父类的构造器？
    答：1. 子类的构造器的第一行默认有一个super()调用父类的无参构造器，写不写都存在
    2. 当我们调用子类构造器初始化子类对象数据的时候，必须先调用父类构造器初始化继承自父类的属性和行为(先有爸爸，后有儿子)

    1.10 this和super

  • this代表了当前对象的引用(继承中指代子类对象)
    • this.子类成员变量
    • this.子类成员方法
    • this(....):可以根据参数匹配访问本类中其他构造器
  • super代表了父类对象的引用(继承中指代了父类对象空间)
    • super.父类成员变量
    • super.父类的成员方法
    • super(....):可以根据参数匹配访问父类的构造器

注意：

  • this(...)借用本类其他构造器
  • super(...)调用父类的构造器
  • this(...)和super(...)必须放在构造器的第一行，否则报错
  • 所以this(...)和super(...)不能同时出现在构造器中！！

    1.11 继承特点

    继承的特点：
  1. 单继承： 一个类只能继承一个直接父类
  2. 多层继承：一个类可以间接继承多个父类(C继承B,B继承A)
  3. 一个类可以有多个子类（C继承B，D也继承B，B就有了C,D两个子类）
  4. 一个类要么默认继承了Object类，要么间接继承了Object类，Object类是Java中的祖宗类

    1.12 引用类型作为方法参数和返回值

    – 引用类型作为java的数据类型，自然可以作为方法的参数类型和返回值类型
    – 除了基本数据类型就是引用数据类型了
  • 基本数据类型
    • byte，short，int，long，char，boolean，float，double
  • 引用类型
    • 就是我们自己创建的类型
    • 类
    • 接口
    • 数组

      2. 面试常考

      2.1 八种访问形式问答

  1. 实例方法是否可以直接访问实例成员变量？
    答：可以的，因为它们都属于对象
  2. 实例方法是否可以直接访问静态成员变量？
    答：可以的，静态成员变量可以被共享访问
  3. 实例方法是否可以直接访问实例方法？
    答：可以的，实例方法和实例方法都属于对象
  4. 实例方法是否可以直接访问静态方法？
    答：可以的，静态方法可以被共享访问
  5. 静态方法是否可以直接访问实例变量？
    答：不可以，静态方法属于类，实例变量属于对象，实例变量必须用对象访问
  6. 静态方法是否可以直接访问静态变量？
    答：可以的，静态成员变量可以被共享访问
  7. 静态方法是否可以直接访问实例方法?
    答：不可以，实例方法必须被对象访问

  8. 静态方法是否可以直接访问静态方法？
    答：可以的，静态方法可以被共享访问

    2.2 继承

  9. 子类中不能继承父类东西是什么？
    答：子类不能继承父类的构造器，子类有自己的构造器

  10. 子类是否可以继承父类的私有成员(私有成员变量，私有成员方法)？
    答：有争议，我认为子类是可以继承父类的私有成员的，只是不能直接访问而已

  11. 子类上是否可以继承父类的静态成员？
    答：有争议，我认为子类是不能继承父类的静态成员

    2.3 重写

  12. 静态方法和私有方法是否可以被重写？
    答：不可以，加上@Override会报错

    2.4 继承后构造器特点

  13. 为什么子类的构造器会调用父类的构造器
    答：子类的构造器第一行默认有super()调用父类的无参构造器，写不写都存在

    2.5 单继承

  14. 为什么Java是单继承的？

答： 反证法

  1. // 假如Java可以多继承，请看如下代码
  2. class A{
  3.     // 成员方法
  4.     public void test(){
  5.         System.out.println("A");
  6.     }
  7. }
  9. class B{
  10.     // 成员方法
  11.     public void test(){
  12.         System.out.println("B");
  13.     }
  14. }
  15. class C extends  A,B{
  16.     public static void main(String[] args){
  17.         C c = new C();
  18.         c.test(); //出现了类的二义性！所以Java不能多继承！！
  19.     }
  20. }