小张日记

关于final关键字

final关键字代表最终，不可改变的。

final关键字有常见的四种用法：

• 可以用来修饰一个类
• 可以用来修饰一个方法
• 可以用来修饰一个局部变量
• 可以用来修饰一个成员变量

---

用final修饰一个类

当final关键字用来修饰一个类的时候。

格式：

public final class 类名称 {
        //.....
}

含义：当前这个类不能有任何的子类。（太监类）

注意： 一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没儿子），但是可以对父类继承的方法覆盖重写。

---

用final修饰一个方法

当final关键字来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。

格式：

修饰符 final 返回值类型 方法名称（参数列表）{
            方法体....
}

注意事项： 对于类、方法来说，abstract关键字与final关键字不能同时使用，因为矛盾，

---

用final修饰一个局部变量

用final修饰局部变量可以不对其进行赋值，那么这个局部变量将会是初始值不能再改变，当然也可以对其赋值，赋值后也不能再改变。

用final修饰一个成员变量

对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。但是用final修饰的成员变量一定要对其手动赋值，不会再给默认值了。赋值方法有两种，妖媚直接赋值，要么通过构造方法赋值。

---

此为final关键字的一些粗略简介，更多详细信息请自己查询相关内容。

System类

java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作。

在System类的API文档中，常用的方法有：

public static long currentTimeMillis(); 返回以毫秒为单位的当前时间。

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);将数组中指定数据拷贝到另一个数组中。

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)方法
参数：
    src - 源数组。
    srcPos - 源数组中的起始位置。
    dest - 目标数组。
    destPos - 目标数据中的起始位置。
    length - 要复制的数组元素的数量。

---

StringBuilder类

java.lang.StringBuilder类：字符串缓冲区，可以提高字符串的效率。

构造方法：
StringBuilder()；构造一个不带任何字符的字符串生成器，其初始容量为 16 个字符。

StringBuilder(String str)；构造一个字符串生成器，并初始化为指定的字符串内容。

常用的成员方法：
public StringBuilder append(...)；添加任意类型数据的字符串形式，并返回当前对象自身。

public String toString()；将当前的StringBuilder对象转换为String对象。

StingBuilder与String的区别

StringBuilder对象中的内容可以改变，而String不行。

---

以上是关于这两个类的简要描述，如需知道更多请自己查询。

Object类中为我们提供了一些方法，当我们创建自定义类的对象后，想要使用这些方法，可能无法实现我们想要的需求，因此需要我们对Object类的一些方法进行重写。

toString方法

如果不重写此方法，直接打印输出时，toString是将其中的地址值转换为字符串，也就是打印出来的是对象的地址值，因此需要重写，才能将其中的内容转换为字符串，才能把对象中的内容打印出来。

equals方法

Object类的equals方法，默认比较的是两个对象的地址值，没有意义，所以要重写equals方法，比较两个对象的属性。

问题：

• 隐含着一个多态

多态的弊端：无法使用子类的特有内容（属性和方法）

Object obj = p2 = new Person(“古力娜扎”，19);

• 解决：可以使用向下转型，把obj类型转换为Person。

---

这些方法都可以用IDEA的自动代码生成，不用手写

装箱（拿int类型与Integer类型为例）

装箱：把基本的数据类型包装到包装类中。

构造方法：

Integer(int value)；构造一个新分配的 Integer 对象，它表示指定的 int 值。

Integer(String s)；构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。

注意：传递的字符串必须是与此包装类相同的基本类型字符串，否则会抛出异常。

成员方法：

static Integer valueOf(int i)；返回一个表示指定的 int 值的 Integer 实例。

static Integer valueOf(String s)；返回保存指定的 String 的值的 Integer 对象。

---

拆箱（拿int类型与Integer类型为例）

拆箱：在包装类中取出基本类型的数据。

成员方法：
int intValue()；以 int 类型返回该 Integer 的值。

---

自动装箱与自动拆箱，如：

自动装箱 Integer integer = 1；

自动拆箱 integer = integer + 2;

integer是包装类，无法进行计算，所以自动拆箱了，然后又赋值给integer，自动装箱了。

其他基本类型与包装类之间的装箱拆箱也与此差不多。

---

有关拆箱装箱简要描述，如需知道更多自己查询。

JAVA中的两个工具类：Arrays与Math

1. Arrays

java.util.Arrays是一个与数组相关的工具类。里面提供了大量静态方法，用来实现数组常见的操作。

其中比较常用的方法

public static String toString(数组)

作用：将参数数组变成字符串（按默认格式：{元素1，元素2，元素3…….}）。

public static void sort(数组)

作用：按照默认升序对数组进行排序。

   

2. Math

java.lang.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学相关运算的操作。

其中比较常用的方法

public static double abs(double num);：获取绝对值。

public static double ceil(double num);：向上取整。

public static double floor(double num);：向下取整。

public static long round(double num);：四舍五入。

tips： Math.PI代表近似圆周率常量（double）

   

---

   

关于这两个工具类的常用方法简单粗略了写了一下，如过想要了解知道更多，请咨询查找有关信息，重点记住Arrays是操作数组的工具类，而Math是和数学有关的工具类。

关于继承

在继承的关系中，一个子类就是一个父类，也就是说，子类可以被当作父类看待。

例如父类是员工，子类是讲师，那么“讲师就是一个员工”。

父类的格式

public clss 父类名称(){
    // ...
}

子类的格式

public class 子类名称 extends 父类名称(){
    //....
}

关于继承中的一些注意事项

1. 在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：
   • 直接通过子类对象访问成员变量：等号左边是谁则优先用谁，没有则向上找。
   • 间接通过成员方法访问成员变量：该方法属于谁就优先用谁，没有则向上找。
2. 子类与父类成员方法重名，创建的对象是谁就优先用谁，否则就向上找。

---

继承中对方法进行覆盖重写

要求

1.字符类成员方法名称一样，参数列表也一样，@Override 写在方法前面，用来检测是不是有效的正确覆盖重写。（这个注解要是不写，只要满足要求，也是正确的方法覆盖重写）

2.子类方法的返回值必须小于等于父类方法的返回值。

例：父类中返回值类型为String类，子类中为Object类，这样是不行的，子类返回值大于父类。

3.子类方法的权限必须大于等于父类方法的权限修饰符

注：public > protected > (default) > private
这个(default)不是关键字default，而是代表什么也不写，留空。

---

继承关系中的构造方法

1.子类构造方法中有一个默认隐含的“super()”调用，所以一定是先调用的父类构造，后执行的子类构造。

2.可以通过super关键字来子类构造调用父类重载构造。

3.super的父类构造调用，必须是子类构造的第一个语句，不能一个子类构造调用多次super构造。

父类构造方法

public Fu() {System.out.println("这是一个父类无参构造方法");}

public Fu(int num) {System.out.println("这是一个父类有参构造方法");}

子类构造方法

public Zi(){
    //        super();  //调用父类无参构造方法
    super(20);      //调用父类重载的构造方法
    System.out.println("这是一个子类构造方法");
}

 public Zi(int num){
    System.out.println("这是一个有参子类构造方法");
}

主方法

输入

public static void main(String[] args) {Zi zi = new Zi();}

输出

这是一个父类有参构造方法（子类的无参构造中调用了父类的有参构造）

这是一个子类构造方法（子类的无参构造方法）

输入

public static void main(String[] args) {Zi zi = new Zi(10);}

输出

这是一个父类无参构造方法（子类的有参构造方法中默认隐含一个父类的无参构造方法）

这是一个有参子类构造方法（子类的有参构造方法）

---

继承中相关的抽象方法

抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。

抽象类：抽象方法所在的类，必须是抽象类才行，在class前加上abstract关键字即可。

如何使用抽象类和抽象方法：

1. 不能直接创建new抽象类对象。

2. 必须用一个子类继承抽象父类。

3. 子类必须覆盖重写父类中的所有抽象方法。

   覆盖重写（实现）：去掉abstract关键字，补上{方法体}。

4. 创建子类对象进行使用。

---

以上就是有关于继承的一些知识的简要概述，如需知道更多请自己查询相关资料。

JAVA中Static的相关内容

Static的中文意思是静态，什么是静态？

静态就是：

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

      用static修饰的成员方法同理这就是类的静态方法。

注意事项

1. 静态只能访问静态，静态不能访问非静态。 因为在内存当中，先有的静态内容，后有的非静态内容，先人不知道后人，后人知道先人。

2. 静态方法中不能用this。 因为this代表当前对象，通过谁调用的方法，谁就是当前对象，但是静态和对象没关系。

关于静态有一种特殊使用方法：静态代码块

public class 类名称 {
    static {
        // 静态代码块的内容
    }
} 

特点：当第一次用到本类时，静态代码块执行唯一一次。当类中某一些只会用到唯一一次的代码，就可以使用静态代码块，无需再将这些代码写成一个方法，然后调用方法执行，静态代码块自己会执行。

 

---

 

关于静态还有很多需要深入了解的知识，这里只是浅显的讲了一下常用的东西，静态最主要的就是属于类而和创建的对象无关。

String字符串

String字符串的特点

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

关于字符串内容永不可变

String str = “Hello”；
str实际上是对“Hello”的引用，”Hello”才是在堆中被创建的字符串对象，里面存的的字符串内容是Hello，而str则存放的是Hello这个字符串对象的地址。

当出现这种情况时：str = “world”；
原本Hello那个字符串的内容并没有改变，只是在堆中新创建了一个world的字符串对象，而str成了world的引用，存放的是world这个字符串对象的地址。
所以字符串内容是永不可变的，你感觉到的变了其实是引用地址的改变。

---

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

三种构造方法

1. public String(); 创建一个空白字符串，不含有任何内容。

2. public String(char[] array); 根据字符数组的内容，来创建对应的字符串。

3. public String(byte[] array); 根据字节数组的内容，来创建对应的字符串。

一种直接创建

String str = “Hello”;

---

String类中常用的一些方法

与转换相关的方法

public char[] toCharArray(); 将当前字符串拆封为字符数组作为返回值。

public byte[] getBytes(); 获得当前字符串底层的字节数组。

public String replace(CharSequence oldString,CharSequence newString);将所有出现的老字符串替换为新字符串，返回替换之后的结果字符串。CharSequence意思就是说可以接收字符串类型。游戏中的关键字屏蔽可以用这种方法

与比较相关的方法

==用于字符串的比较是对对象的地址进行比较，如果要对内容进行比较，可以用下面两个方法。

public boolean equals(Object obj); 参数可以是任何对象，只有参数是一个字符串并且内容相同才会返回true，否则返回false。

“Hello”.equals(str);
注意：这样写比str.equals(“Hello”)好，因为str.equals(“Hello”)可能会抛出空指针异常，str是一个变量，而”Hello”.equals(str)不会抛出这个异常，因为“Hello”是一个常量，永远不会空指针。

public boolean equalsIgnoreCase(String str);忽略大小写进行字符串比较

str = “ABC”;
“abc”.equalsIgnoreCase(str) = true;

与获取相关的一些方法

public int length(); 获取字符串中字符的个数，拿到字符串长度。

public String concat(String str); 将当前字符串和参数字符串拼接成为返回值新的字符串。

public char charAt(int index); 获取指定索引位置的单个字符。

public int indexOf(String str); 查找参数字符串在本字符串中首次出现的位置，若不存在则返回-1。

字符串的截取方法

public String substring(int index); 从参数位置开始一直到字符串末尾返回新字符串。

public String substring(int begin, int end); 从begin开始一直到end结束返回新字符串，包括begin不包括end。

分割字符串的方法

public String[] split(String regex); 按照参数的规则，将字符串切割成若干部分。

split方法的参数实际上是一个“正则表达式”，如果用英文句点“.”进行切分，必须写“\\.”，因为需要转义。

---

基本类型与字符串类型之间的相互转换

基本类型与字符串类型之间的互相转换。

基本类型–>字符串（String）：

1. 基本类型的值 + “”。 最简单的方法，工作中常用。

2. 包装类的静态方法toString（参数），不是Object类的toString。

static String toString(包装类的基本类型参数)；返回一个表示指定整数的 String 对象。

3. String类的静态方法valueOf（基本类型参数）；返回参数的字符串表示形式。

字符串（String）–>基本类型：

使用包装类的静态方法parse基本类型名称（字符串）；

如：Integer类：static int parseInt(String s);

---

关于常量池的概念

1. 对于引用类型来说，==进行的是地址值的比较。

2. 双引号直接写的字符串在常量池当中，new的不在池中。

   public static void main(String[] args) {
       String str1 = "a,b,c";
       String str2 = "a,b,c";
   
       char[] array = {'a', 'b', 'c'};
       String str3 = new String(array);
   
       System.out.println(str1 == str2);   //true
       System.out.println(str1 == str3);   //false
       System.out.println(str2 == str3);   //false
   }

原理

---

以上是对String字符串类型有关内容的一些小小整理，想要了解更多请自己查询有关知识。

关于接口

接口就是多个类的公共规范。

接口是一种引用数据类型，最重要的内容就是其中的：抽象方法。

接口与父子类继承有相似之处，可以把接口中的内容交给“实现类”来实现，接口与父子类相比，更加灵活，一个“实现类”可以多实现多个接口，而在父子类中只能单继承，一个子类只有一个父类。

接口的定义格式

public interface 接口名称{
    //接口方法
}

接口中的内容
   

• 如果是java7，那么接口中可以包含的内容有：

  1. 常量（必须使用public static final三个关键字修饰，可以省略不写，但是初学者不建议这样做，常量必须有赋值）

  2. 抽象方法（有abstract关键字修饰）

• 如果是java8，还可以额外包含有：

  3. 默认方法（可以解决接口升级的问题，即已经有了接口的实现类以后，接口升级不会影响已经使用此接口的实现类）
  4. 静态方法

• 如果是java9，还可以额外包含有：

  5. 私有方法（接口中的私有方法用来作为两个方法的公有方法，解决两个方法之间代码重复的问题。但是这个方法不应该让实现类使用，应该是私有的。有普通私有方法与静态私有方法两种，分别解决多个默认方法之间代码重复的问题与多个静态方法之间代码重复的问题）

接口的使用步骤
   

1. 接口不能直接使用，必须有一个“实现类”来“实现”接口。

       格式：

public class 实现类名称 implements 接口名称 {
       //....
}

2. 接口的实现类必须覆盖重写（实现）接口中所有的抽象方法，如果实现类没有全部覆盖重写，那么实现类必须是抽象类。

3. 创建实现类的对象，进行使用。

实现类可以多实现多个接口

注意事项：
   

1. 如果实现类实现的多个接口中，有重复的抽象方法，那么只需要覆盖重写一次即可。

2. 如果实现类实现的多个接口中，有重复的默认方法，那么实现类必须要对重复的默认方法覆盖重写。

3. 一个类如果直接父类中的方法与接口中的默认方法产生了冲突，优先使用父类当中的方法，父类的优先级大于接口。

接口与接口之间也可以多继承

注意事项：
   

1. 多个父接口当中的抽象方法如果重复，没关系，因为在子接口当中本就要覆盖重写实现抽象方法。

2. 多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，而且必须要带着default关键字。

---

更多接口的详细信息可以咨询查找。

Array与ArrayList的区别

数组的长度不可以发生改变，但是ArrayList的长度是可以随意变化的。

关于ArrayList

对于ArrayList来说，用一个尖括号代表泛型。

泛型：就是装在集合当中的所有元素，全都是统一的一种类型。

注意：泛型 只能 是引用类型，不能 是基本类型（byte,short,int,long,float,double,boolean,char）

如果想创建一个基本类型的ArrayList

可以使用基本类型所对应的“包装类”

基本类型	包装类（引用类型）
byte	Byte
short	Short
int	Integer
Long	Long
float	Float
double	Double
Boolean	Boolean
char	Character

ArrayList的常用方法

public boolean add(E e); 向集合当中添加元素，参数的类型和泛型一致

public E get(int index); 从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素

public E remove(int index); 从集合当中删除元素，参数是索引编号，返回值就是被删除的元素

public int size(); 获取集合的尺寸长度，返回值就是集合当中包含的元素的个数