JavaSE基础【吐血整理汇总】

版权声明:本博客为本人原创,本人拥有其版权。如有遗漏之处,欢迎指出,本人将于24小时内做出回复并进行确认。 https://blog.csdn.net/flyingwzb/article/details/85002850

作为JavaSE基础的进阶版也希望给大家一些帮助:https://blog.csdn.net/flyingwzb/article/details/85130517

1. 方法

1.1 定义方法的完整格式
  • 定义方法的完整格式:

    修饰符 返回值类型 方法名称(参数类型 参数名称, ...) {
        方法体
        return 返回值;
    }
    
    1. 修饰符:现阶段的固定写法,public static
    2. 返回值类型:也就是方法最终产生的数据结果是什么类型
    3. 方法名称:方法的名字,规则和变量一样,小驼峰
    4. 参数类型:进入方法的数据是什么类型
    5. 参数名称:进入方法的数据对应的变量名称

      PS:参数如果有多个,使用逗号进行分隔
    6. 方法体:方法需要做的事情,若干行代码
    7. return:两个作用,第一停止当前方法,第二将后面的返回值还给调用处
    8. 返回值:也就是方法执行后最终产生的数据结果

      注意:return后面的“返回值”,必须和方法名称前面的“返回值类型”,保持对应。
  • 定义一个两个int数字相加的方法。三要素:

    • 返回值类型:int
    • 方法名称:sum
    • 参数列表:int a, int b
  • 方法的三种调用格式。

    1. 单独调用:方法名称(参数);
    2. 打印调用:System.out.println(方法名称(参数));
    3. 赋值调用:数据类型 变量名称 = 方法名称(参数);

注意:此前学习的方法,返回值类型固定写为void,这种方法只能够单独调用,不能进行打印调用或者赋值调用。

1.2 有无参数的方法
  • 有参数:小括号当中有内容,当一个方法需要一些数据条件,才能完成任务的时候,就是有参数。

    例如两个数字相加,必须知道两个数字是各自多少,才能相加。
  • 无参数:小括号当中留空。一个方法不需要任何数据条件,自己就能独立完成任务,就是无参数。

    例如定义一个方法,打印固定10次HelloWorld。
1.3 使用方法注意事项
  1. 方法应该定义在类当中,但是不能在方法当中再定义方法。不能嵌套。
  2. 方法定义的前后顺序无所谓。
  3. 方法定义之后不会执行,如果希望执行,一定要调用:单独调用、打印调用、赋值调用。
  4. 如果方法有返回值,那么必须写上“return 返回值;”,不能没有。
  5. return后面的返回值数据,必须和方法的返回值类型,对应起来。
  6. 对于一个void没有返回值的方法,不能写return后面的返回值,只能写return自己。
  7. 对于void方法当中最后一行的return可以省略不写。
  8. 一个方法当中可以有多个return语句,但是必须保证同时只有一个会被执行到,两个return不能连写。
1.4 方法的重载
  • 对于功能类似的方法来说,因为参数列表不一样,却需要记住那么多不同的方法名称,太麻烦。
  • 方法的重载(Overload):多个方法的名称一样,但是参数列表不一样。
    • 好处:只需要记住唯一一个方法名称,就可以实现类似的多个功能。
  1. 方法重载与下列因素相关:
    1. 参数个数不同
    2. 参数类型不同
    3. 参数的多类型顺序不同
  2. 方法重载与下列因素无关:
    1. 与参数的名称无关
    2. 与方法的返回值类型无关

2. 数组

2.1 数组的概念与特点
  • 数组的概念:是一种容器,可以同时存放多个数据值。
  • 数组的特点:
    • 数组是一种引用数据类型
    • 数组当中的多个数据,类型必须统一
    • 数组的长度在程序运行期间不可改变
  • 数组的初始化:在内存当中创建一个数组,并且向其中赋予一些默认值。
    • 两种常见的初始化方式:
    1. 动态初始化(指定长度)
    2. 静态初始化(指定内容)
  • 动态初始化数组的格式:
    数据类型[] 数组名称 = new 数据类型[数组长度];
    • 解析含义:
    1. 左侧数据类型:也就是数组当中保存的数据,全都是统一的什么类型
    2. 左侧的中括号:代表我是一个数组
    3. 左侧数组名称:给数组取一个名字
    4. 右侧的new:代表创建数组的动作
    5. 右侧数据类型:必须和左边的数据类型保持一致
    6. 右侧中括号的长度:也就是数组当中,到底可以保存多少个数据,是一个int数字
2.2 动态初始化与静态初始化
  • 动态初始化(指定长度):在创建数组的时候,直接指定数组当中的数据元素个数。
  • 静态初始化(指定内容):在创建数组的时候,不直接指定数据个数多少,而是直接将具体的数据内容进行指定。
  • 静态初始化基本格式:
    • 数据类型[] 数组名称 = new 数据类型[] { 元素1, 元素2, … };
  • 注意事项:
    • 虽然静态初始化没有直接告诉长度,但是根据大括号里面的元素具体内容,也可以自动推算出来长度。
2.3 静态初始化格式
  • 使用静态初始化数组的时候,格式还可以省略一下。
  • 标准格式:
    • 数据类型[] 数组名称 = new 数据类型[] { 元素1, 元素2, … };
  • 省略格式:
    • 数据类型[] 数组名称 = { 元素1, 元素2, … };
  • 注意事项:
    1. 静态初始化没有直接指定长度,但是仍然会自动推算得到长度。
    2. 静态初始化标准格式可以拆分成为两个步骤。
    3. 动态初始化也可以拆分成为两个步骤。
    4. 静态初始化一旦使用省略格式,就不能拆分成为两个步骤了。
  • 使用建议:
    • 如果不确定数组当中的具体内容,用动态初始化;否则,已经确定了具体的内容,用静态初始化。
2.4 数组索引
  • 数组的索引编号从0开始,一直到“数组的长度-1”为止。
  • 如果访问数组元素的时候,索引编号并不存在,那么将会发生
    数组索引越界异常
    ArrayIndexOutOfBoundsException
  • 原因:索引编号写错了。
    解决:修改成为存在的正确索引编号。

3. 面向对象

面向过程:当需要实现一个功能的时候,每一个具体的步骤都要亲力亲为,详细处理每一个细节。
面向对象:当需要实现一个功能的时候,不关心具体的步骤,而是找一个已经具有该功能的人,来帮我做事儿。
3.1 new对象
  • 通常情况下,一个类并不能直接使用,需要根据类创建一个对象,才能使用。
  1. 导包:也就是指出需要使用的类,在什么位置。

    import 包名称.类名称;

    import cn.itcast.day06.demo01.Student;

    对于和当前类属于同一个包的情况,可以省略导包语句不写。
  2. 创建,格式:

    类名称 对象名 = new 类名称();

    Student stu = new Student();
  3. 使用,分为两种情况:

    使用成员变量:对象名.成员变量名

    使用成员方法:对象名.成员方法名(参数)

    (也就是,想用谁,就用对象名点儿谁。)
  • 注意事项:
    • 如果成员变量没有进行赋值,那么将会有一个默认值,规则和数组一样。
3.2 局部变量和成员变量
  1. 定义的位置不一样【重点】

    局部变量:在方法的内部

    成员变量:在方法的外部,直接写在类当中

  2. 作用范围不一样【重点】

    局部变量:只有方法当中才可以使用,出了方法就不能再用

    成员变量:整个类全都可以通用。

  3. 默认值不一样【重点】

    局部变量:没有默认值,如果要想使用,必须手动进行赋值

    成员变量:如果没有赋值,会有默认值,规则和数组一样

  4. 内存的位置不一样(了解)

    局部变量:位于栈内存

    成员变量:位于堆内存

  5. 生命周期不一样(了解)

    局部变量:随着方法进栈而诞生,随着方法出栈而消失

    成员变量:随着对象创建而诞生,随着对象被垃圾回收而消失

3.3 面向对象三大特征
  • 面向对象三大特征:封装、继承、多态
  • 封装性在Java当中的体现:
    1. 方法就是一种封装
    2. 关键字private也是一种封装
  • 封装就是将一些细节信息隐藏起来,对于外界不可见。
3.4 封装
  • 问题描述:定义Person的年龄时,无法阻止不合理的数值被设置进来。
  • 解决方案:用private关键字将需要保护的成员变量进行修饰。
  • 一旦使用了private进行修饰,那么本类当中仍然可以随意访问。
    但是!超出了本类范围之外就不能再直接访问了。
  • 间接访问private成员变量,就是定义一对儿Getter/Setter方法
  • 必须叫setXxx或者是getXxx命名规则。
    • 对于Getter来说,不能有参数,返回值类型和成员变量对应;
    • 对于Setter来说,不能有返回值,参数类型和成员变量对应。
3.5 构造方法
  • 构造方法是专门用来创建对象的方法,当我们通过关键字new来创建对象时,其实就是在调用构造方法。
  • 格式:
    public 类名称(参数类型 参数名称) {
        方法体
    }
    
  • 注意事项:
    1. 构造方法的名称必须和所在的类名称完全一样,就连大小写也要一样
    2. 构造方法不要写返回值类型,连void都不写
    3. 构造方法不能return一个具体的返回值
    4. 如果没有编写任何构造方法,那么编译器将会默认赠送一个构造方法,没有参数、方法体什么事情都不做。
      public Student() {}
    5. 一旦编写了至少一个构造方法,那么编译器将不再赠送。
    6. 构造方法也是可以进行重载的。
      重载:方法名称相同,参数列表不同。
3.6 Java Bean
  • 一个标准的类通常要拥有下面四个组成部分:
    1. 所有的成员变量都要使用private关键字修饰
    2. 为每一个成员变量编写一对儿Getter/Setter方法
    3. 编写一个无参数的构造方法
    4. 编写一个全参数的构造方法
  • 这样标准的类也叫做Java Bean

4. Scanner类

  • Scanner类的功能:可以实现键盘输入数据,到程序当中。
  • 引用类型的一般使用步骤:
    1. 导包

      import 包路径.类名称;

      如果需要使用的目标类,和当前类位于同一个包下,则可以省略导包语句不写。

      只有java.lang包下的内容不需要导包,其他的包都需要import语句。
    2. 创建

      类名称 对象名 = new 类名称();
    3. 使用

      对象名.成员方法名()
  • 获取键盘输入的一个int数字:int num = sc.nextInt();
  • 获取键盘输入的一个字符串:String str = sc.next();
4.1 new对象格式
  • 创建对象的标准格式:
    • 类名称 对象名 = new 类名称();
  • 匿名对象就是只有右边的对象,没有左边的名字和赋值运算符。
    • new 类名称();
  • 注意事项:匿名对象只能使用唯一的一次,下次再用不得不再创建一个新对象。
  • 使用建议:如果确定有一个对象只需要使用唯一的一次,就可以用匿名对象。

5. Random类

  • Random类用来生成随机数字。使用起来也是三个步骤:
  1. 导包

    import java.util.Random;
  2. 创建

    Random r = new Random(); // 小括号当中留空即可
  3. 使用

    获取一个随机的int数字(范围是int所有范围,有正负两种):int num = r.nextInt()

    获取一个随机的int数字(参数代表了范围,左闭右开区间):int num = r.nextInt(3)

    实际上代表的含义是:[0,3),也就是0~2

6. 数组与集合的区别

  • 数组的长度不可以发生改变。
  • 但是ArrayList集合的长度是可以随意变化的。
  • 对于ArrayList来说,有一个尖括号代表泛型。
    • 泛型:也就是装在集合当中的所有元素,全都是统一的什么类型。
    • 注意:泛型只能是引用类型,不能是基本类型。
  • 注意事项:
    • 对于ArrayList集合来说,直接打印得到的不是地址值,而是内容。
    • 如果内容是空,得到的是空的中括号:[]

7. 包装类

  • 如果希望向集合ArrayList当中存储基本类型数据,必须使用基本类型对应的“包装类”。
    基本类型 包装类(引用类型,包装类都位于java.lang包下)
    byte Byte
    short Short
    int Integer 【特殊】
    long Long
    float Float
    double Double
    char Character 【特殊】
    boolean Boolean
  • 从JDK 1.5+开始,支持自动装箱、自动拆箱。
    • 自动装箱:基本类型 --> 包装类型
    • 自动拆箱:包装类型 --> 基本类型

8. String类

java.lang.String类代表字符串。

API当中说:Java 程序中的所有字符串字面值(如 “abc” )都作为此类的实例实现。

其实就是说:程序当中所有的双引号字符串,都是String类的对象。(就算没有new,也照样是。)

  • 字符串的特点:
    1. 字符串的内容永不可变。【重点】
    2. 正是因为字符串不可改变,所以字符串是可以共享使用的。
    3. 字符串效果上相当于是char[]字符数组,但是底层原理是byte[]字节数组。

创建字符串的常见3+1种方式。

  • 三种构造方法:
    • public String():创建一个空白字符串,不含有任何内容。
    • public String(char[] array):根据字符数组的内容,来创建对应的字符串。
    • public String(byte[] array):根据字节数组的内容,来创建对应的字符串。
  • 一种直接创建:
    • String str = “Hello”; // 右边直接用双引号

      注意:直接写上双引号,就是字符串对象。
8.1 String类方法使用
  • public int length():获取字符串当中含有的字符个数,拿到字符串长度。
  • public String concat(String str):将当前字符串和参数字符串拼接成为返回值新的字符串。
  • public char charAt(int index):获取指定索引位置的单个字符。(索引从0开始。)
  • public int indexOf(String str):查找参数字符串在本字符串当中首次出现的索引位置,如果没有返回-1值。

  • public String substring(int index):截取从参数位置一直到字符串末尾,返回新字符串。
  • public String substring(int begin, int end):截取从begin开始,一直到end结束,中间的字符串。

    备注:[begin,end),包含左边,不包含右边。

  • public char[] toCharArray():将当前字符串拆分成为字符数组作为返回值。
  • public byte[] getBytes():获得当前字符串底层的字节数组。
  • public String replace(CharSequence oldString, CharSequence newString):

    将所有出现的老字符串替换成为新的字符串,返回替换之后的结果新字符串。

    备注:CharSequence意思就是说可以接受字符串类型。

  • public String[] split(String regex):按照参数的规则,将字符串切分成为若干部分。

注意事项:

split方法的参数其实是一个“正则表达式”,今后学习。

今天要注意:如果按照英文句点“.”进行切分,必须写"\\."(两个反斜杠)

9. static关键字

如果一个成员变量使用了static关键字,那么这个变量不再属于对象自己,而是属于所在的类。多个对象共享同一份数据。

9.1 static关键字注意事项
  • 一旦使用static修饰成员方法,那么这就成为了静态方法。静态方法不属于对象,而是属于类的。
  • 如果没有static关键字,那么必须首先创建对象,然后通过对象才能使用它。
  • 如果有了static关键字,那么不需要创建对象,直接就能通过类名称来使用它。
  • 无论是成员变量,还是成员方法。如果有了static,都推荐使用类名称进行调用。
    • 静态变量:类名称.静态变量
    • 静态方法:类名称.静态方法()
  • 注意事项:
    • 静态不能直接访问非静态。

      原因:因为在内存当中是【先】有的静态内容,【后】有的非静态内容。

      “先人不知道后人,但是后人知道先人。”
    • 静态方法当中不能用this。

      原因:this代表当前对象,通过谁调用的方法,谁就是当前对象。
9.2 静态代码块
  • 静态代码块的格式是:
    public class 类名称 {
        static {
            // 静态代码块的内容
        }
    }
    
  • 特点:当第一次用到本类时,静态代码块执行唯一的一次。

    静态内容总是优先于非静态,所以静态代码块比构造方法先执行。
  • 静态代码块的典型用途:
    用来一次性地对静态成员变量进行赋值。

10. Math类

  • java.util.Math类是数学相关的工具类,里面提供了大量的静态方法,完成与数学运算相关的操作。
    public static double abs(double num):获取绝对值。有多种重载。<br>
    
    public static double ceil(double num):向上取整。<br>
    
    public static double floor(double num):向下取整。<br>
    
    public static long round(double num):四舍五入。<br>
    
  • Math.PI代表近似的圆周率常量(double)。

11. 继承

  • 在继承的关系中,“子类就是一个父类”。也就是说,子类可以被当做父类看待。
    • 例如父类是员工,子类是讲师,那么“讲师就是一个员工”。关系:is-a。
  • 定义父类的格式:(一个普通的类定义)
    public class 父类名称 {
        // ...
    }
    
  • 定义子类的格式:
    public class 子类名称 extends 父类名称 {
    // ...
    }
    
11.1 继承访问成员变量
  • 在父子类的继承关系当中,如果成员变量重名,则创建子类对象时,访问有两种方式:
    • 直接通过子类对象访问成员变量:
      • 等号左边是谁,就优先用谁,没有则向上找。
    • 间接通过成员方法访问成员变量:
      • 该方法属于谁,就优先用谁,没有则向上找。
11.2 继承中变量的访问
  • 局部变量: 直接写成员变量名
  • 本类的成员变量: this.成员变量名
  • 父类的成员变量: super.成员变量名
11.3 继承中方法重写
  • 在父子类的继承关系当中,创建子类对象,访问成员方法的规则:
    • 创建的对象是谁,就优先用谁,如果没有则向上找。
  • 注意事项:
    • 无论是成员方法还是成员变量,如果没有都是向上找父类,绝对不会向下找子类的。
  • 重写(Override)
    • 概念:在继承关系当中,方法的名称一样,参数列表也一样。
    • 重写(Override):方法的名称一样,参数列表【也一样】。覆盖、覆写。
    • 方法的覆盖重写特点:创建的是子类对象,则优先用子类方法。
  • 重载(Overload):方法的名称一样,参数列表【不一样】。
11.4 方法覆盖重写的注意事项
  1. 必须保证父子类之间方法的名称相同,参数列表也相同。
    • @Override:写在方法前面,用来检测是不是有效的正确覆盖重写。
    • 这个注解就算不写,只要满足要求,也是正确的方法覆盖重写。
  2. 子类方法的返回值必须【小于等于】父类方法的返回值范围。
    • 小扩展提示:java.lang.Object类是所有类的公共最高父类(祖宗类),java.lang.String就是Object的子类。
  3. 子类方法的权限必须【大于等于】父类方法的权限修饰符。
    • 小扩展提示:public > protected > (default) > private
    • 备注:(default)不是关键字default,而是什么都不写,留空。
11.5 继承中构造方法访问
  • 继承关系中,父子类构造方法的访问特点:
    1. 子类构造方法当中有一个默认隐含的“super()”调用,所以一定是先调用的父类构造,后执行的子类构造。
    2. 子类构造可以通过super关键字来调用父类重载构造。
    3. super的父类构造调用,必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
  • 总结:
    • 子类必须调用父类构造方法,不写则赠送super();
    • 写了则用写的指定的super调用,super只能有一个,还必须是第一个。

12. 抽象

  • 抽象方法:就是加上abstract关键字,然后去掉大括号,直接分号结束。
  • 抽象类:抽象方法所在的类,必须是抽象类才行。在class之前写上abstract即可。
  • 如何使用抽象类和抽象方法:
    1. 不能直接创建new抽象类对象。
    2. 必须用一个子类来继承抽象父类。
    3. 子类必须覆盖重写抽象父类当中所有的抽象方法。

      覆盖重写(实现):子类去掉抽象方法的abstract关键字,然后补上方法体大括号。
    4. 创建子类对象进行使用。

13. 接口

  • 接口就是多个类的公共规范。
  • 接口是一种引用数据类型,最重要的内容就是其中的:抽象方法。
  • 如何定义一个接口的格式:
    public interface 接口名称 {
        // 接口内容
    }
    
  • 备注:换成了关键字interface之后,编译生成的字节码文件仍然是:.java --> .class。
  • 如果是Java 7,那么接口中可以包含的内容有:
    1. 常量
    2. 抽象方法
  • 如果是Java 8,还可以额外包含有:
    3. 默认方法
    4. 静态方法
  • 如果是Java 9,还可以额外包含有:
    5. 私有方法
  • 接口使用步骤:
    1. 接口不能直接使用,必须有一个“实现类”来“实现”该接口。

      格式:
      public class 实现类名称 implements 接口名称 {
          // ...
      }
      
    2. 接口的实现类必须覆盖重写(实现)接口中所有的抽象方法。

      实现:去掉abstract关键字,加上方法体大括号。
    3. 创建实现类的对象,进行使用。
  • 注意事项:
    • 如果实现类并没有覆盖重写接口中所有的抽象方法,那么这个实现类自己就必须是抽象类。
13.1 接口实现重点
  1. 接口的默认方法,可以通过接口实现类对象,直接调用。
  2. 接口的默认方法,也可以被接口实现类进行覆盖重写。
13.2 接口中静态方法的调用
  • 注意事项:不能通过接口实现类的对象来调用接口当中的静态方法。
  • 正确用法:通过接口名称,直接调用其中的静态方法。
  • 格式:
    • 接口名称.静态方法名(参数);
13.3 接口中定义抽象方法
  • 在任何版本的Java中,接口都能定义抽象方法。
  • 格式:
    public abstract 返回值类型 方法名称(参数列表);
  • 注意事项:
    1. 接口当中的抽象方法,修饰符必须是两个固定的关键字:public abstract
    2. 这两个关键字修饰符,可以选择性地省略。(今天刚学,所以不推荐。)
    3. 方法的三要素,可以随意定义。
13.4 接口中的常量
  • 接口当中也可以定义“成员变量”,但是必须使用public static final三个关键字进行修饰。
  • 从效果上看,这其实就是接口的【常量】。
  • 格式:
    public static final 数据类型 常量名称 = 数据值;
  • 备注:
    一旦使用final关键字进行修饰,说明不可改变。
  • 注意事项:
    1. 接口当中的常量,可以省略public static final,注意:不写也照样是这样。
    2. 接口当中的常量,必须进行赋值;不能不赋值。
    3. 接口中常量的名称,使用完全大写的字母,用下划线进行分隔。(推荐命名规则)
13.5 接口定义默认方法
  • 从Java 8开始,接口里允许定义默认方法。
  • 格式
    public default 返回值类型 方法名称(参数列表) {
        方法体
    }
    
  • 备注:接口当中的默认方法,可以解决接口升级的问题。
  • 【私有方法】
    • 问题描述:
      • 我们需要抽取一个共有方法,用来解决两个默认方法之间重复代码的问题。
      • 但是这个共有方法不应该让实现类使用,应该是私有化的。
    • 解决方案:
      • 从Java 9开始,接口当中允许定义私有方法。
      1. 普通私有方法,解决多个默认方法之间重复代码问题
        • 格式
        private 返回值类型 方法名称(参数列表) {
            方法体
        }
        
      2. 静态私有方法,解决多个静态方法之间重复代码问题
        • 格式:
        private static 返回值类型 方法名称(参数列表) {
            方法体
        }
        
13.6 接口定义静态方法
  • 从Java 8开始,接口当中允许定义静态方法。
  • 格式:
    public static 返回值类型 方法名称(参数列表) {
        方法体
    }
    
  • 提示:就是将abstract或者default换成static即可,带上方法体。
13.7 接口使用注意事项
  1. 接口是没有静态代码块或者构造方法的。
  2. 一个类的直接父类是唯一的,但是一个类可以同时实现多个接口。
    • 格式:
    public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB {
        // 覆盖重写所有抽象方法
    }
    
  3. 如果实现类所实现的多个接口当中,存在重复的抽象方法,那么只需要覆盖重写一次即可。
  4. 如果实现类没有覆盖重写所有接口当中的所有抽象方法,那么实现类就必须是一个抽象类。
  5. 如果实现类锁实现的多个接口当中,存在重复的默认方法,那么实现类一定要对冲突的默认方法进行覆盖重写。
  6. 一个类如果直接父类当中的方法,和接口当中的默认方法产生了冲突,优先用父类当中的方法。
13.8 类与接口的关系
  1. 类与类之间是单继承的。直接父类只有一个。
  2. 类与接口之间是多实现的。一个类可以实现多个接口。
  3. 接口与接口之间是多继承的。
  • 注意事项:
    1. 多个父接口当中的抽象方法如果重复,没关系。
    2. 多个父接口当中的默认方法如果重复,那么子接口必须进行默认方法的覆盖重写,【而且带着default关键字】。

14. 多态

  • 代码当中体现多态性,其实就是一句话:父类引用指向子类对象。
  • 格式:

    父类名称 对象名 = new 子类名称();

    或者:

    接口名称 对象名 = new 实现类名称();
14.1 多态访问
  • 在多态的代码当中,成员方法的访问规则是:
    • 看new的是谁,就优先用谁,没有则向上找。
  • 口诀:编译看左边,运行看右边。
  • 对比一下:
    • 成员变量:编译看左边,运行还看左边。
    • 成员方法:编译看左边,运行看右边。
14.2 向上向下转型
  • 向上转型一定是安全的,没有问题的,正确的。但是也有一个弊端:
    • 对象一旦向上转型为父类,那么就无法调用子类原本特有的内容。
  • 解决方案:用对象的向下转型【还原】。

15. final关键字

  • final关键字代表最终、不可改变的。
  • 常见四种用法:
    1. 可以用来修饰一个类
    2. 可以用来修饰一个方法
    3. 还可以用来修饰一个局部变量
    4. 还可以用来修饰一个成员变量
15.1 final修饰方法
  • 当final关键字用来修饰一个方法的时候,这个方法就是最终方法,也就是不能被覆盖重写。
  • 格式:
    修饰符 final 返回值类型 方法名称(参数列表) {
        // 方法体
    }
    
  • 注意事项:
    • 对于类、方法来说,abstract关键字和final关键字不能同时使用,因为矛盾。
15.2 final修饰类
  • 当final关键字用来修饰一个类的时候,格式:
    public final class 类名称 {
        // ...
    }
    
  • 含义:当前这个类不能有任何的子类。(太监类)
  • 注意:一个类如果是final的,那么其中所有的成员方法都无法进行覆盖重写(因为没儿子。)
15.3 final修饰成员变量
  • 对于成员变量来说,如果使用final关键字修饰,那么这个变量也照样是不可变。
  1. 由于成员变量具有默认值,所以用了final之后必须手动赋值,不会再给默认值了。
  2. 对于final的成员变量,要么使用直接赋值,要么通过构造方法赋值。二者选其一。
  3. 必须保证类当中所有重载的构造方法,都最终会对final的成员变量进行赋值。

16. Java中有四种权限修饰符

范围 public protected (default) private
同一个类(我自己) YES YES YES YES
同一个包(我邻居) YES YES YES NO
不同包子类(我儿子) YES YES NO NO
不同包非子类(陌生人) YES NO NO NO

注意事项:(default)并不是关键字“default”,而是根本不写。

17. 内部类

  • 如果一个事物的内部包含另一个事物,那么这就是一个类内部包含另一个类。
    • 例如:身体和心脏的关系。又如:汽车和发动机的关系。
  • 分类:
    1. 成员内部类
    2. 局部内部类(包含匿名内部类)
  • 成员内部类的定义格式:
    修饰符 class 外部类名称 {
        修饰符 class 内部类名称 {
            // ...
        }
        // ...
    }
    

注意:内用外,随意访问;外用内,需要内部类对象。

17.1 成员内部类
  • 如何使用成员内部类?有两种方式:
    1. 间接方式:在外部类的方法当中,使用内部类;然后main只是调用外部类的方法。
    2. 直接方式,公式:

      类名称 对象名 = new 类名称();

【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】

17.2 局部内部类1
  • 局部内部类,如果希望访问所在方法的局部变量,那么这个局部变量必须是【有效final的】。
  • 备注:从Java 8+开始,只要局部变量事实不变,那么final关键字可以省略。
  • 原因:
    1. new出来的对象在堆内存当中。
    2. 局部变量是跟着方法走的,在栈内存当中。
    3. 方法运行结束之后,立刻出栈,局部变量就会立刻消失。
    4. 但是new出来的对象会在堆当中持续存在,直到垃圾回收消失。
17.3 局部内部类2
  • 如果一个类是定义在一个方法内部的,那么这就是一个局部内部类。
  • “局部”:只有当前所属的方法才能使用它,出了这个方法外面就不能用了。
  • 定义格式:
    修饰符 class 外部类名称 {
        修饰符 返回值类型 外部类方法名称(参数列表) {
            class 局部内部类名称 {
                // ...
            }
        }
    }
    
17.4 类的权限修饰符
  • public > protected > (default) > private
  • 定义一个类的时候,权限修饰符规则:
    1. 外部类:public / (default)
    2. 成员内部类:public / protected / (default) / private
    3. 局部内部类:什么都不能写
17.5 匿名内部类
  • 如果接口的实现类(或者是父类的子类)只需要使用唯一的一次,
    那么这种情况下就可以省略掉该类的定义,而改为使用【匿名内部类】。
  • 匿名内部类的定义格式:
    接口名称 对象名 = new 接口名称() {
        // 覆盖重写所有抽象方法
    };
    
  • 对格式“new 接口名称() {…}”进行解析:
    1. new代表创建对象的动作
    2. 接口名称就是匿名内部类需要实现哪个接口
    3. {…}这才是匿名内部类的内容
  • 另外还要注意几点问题:
    1. 匿名内部类,在【创建对象】的时候,只能使用唯一一次。

      如果希望多次创建对象,而且类的内容一样的话,那么就需要使用单独定义的实现类了。
    2. 匿名对象,在【调用方法】的时候,只能调用唯一一次。

      如果希望同一个对象,调用多次方法,那么必须给对象起个名字。
    3. 匿名内部类是省略了【实现类/子类名称】,但是匿名对象是省略了【对象名称】

      强调:匿名内部类和匿名对象不是一回事!!!

没有更多推荐了,返回首页

私密
私密原因:
请选择设置私密原因
  • 广告
  • 抄袭
  • 版权
  • 政治
  • 色情
  • 无意义
  • 其他
其他原因:
120
出错啦
系统繁忙,请稍后再试