Java笔记整理三（Java常用类(Scanner,Random,Arraylist,String),static 静态关键字,继承，抽象类，接口，多态，final关键字,内部类）

Java笔记整理三

1.Java常用类

java.lang下的类不需要导包，其他需要。

1.1Scanner类

1.导包
import java.util.Scanner;

2.创建对象
Scanner sc = new Scanner(System.in);

3.调用
变量名.方法名();

Scanner sc = new Scanner(System.in);
int i = sc.nextInt();

匿名对象可以用作参数和返回值

1.2 random类

1. import java.util.Random;
2. Random r = new Random();
3. int number = r.nextInt(10); 生成0~9 之间的数字

1.3 arraylist 集合

引入对象数组

  public static void main(String[] args) {
    //创建学生数组
    Student[] students = new Student[3];
    //创建学生对象
    Student s1 = new Student("曹操",40);
    Student s2 = new Student("刘备",35);
    Student s3 = new Student("孙权",30);
    //把学生对象作为元素赋值给学生数组
    students[0] = s1;
    students[1] = s2;
    students[2] = s3;

ArrayList 长度可以随意改变

使用：

1.导包 import java.util.ArrayList
2.泛型只能是引用类型 jdk1.7以后右括号内可以省略 直接打印得到的是内容

• 创建
  ArrayList list = new ArrayList<>();
• 添加
  list.add(“内容”);

常用方法

1. public boolean add(E e) ：将指定的元素添加到此集合的尾部。
2. public E remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。
3. public E get(int index) ：返回此集合中指定位置上从0开始的元素。返回获取的元素。
4. public int size() ：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。

//遍历输出
for(int i = 0; i < list.size(); i++){
System.out.println(list.get(i));

存储基本数据类型
基本类型	基本类型包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
System.out.println(list);

1.4 String 字符串类

• 字符串内容永不可变
• 字符串可以共享使用
• 效果相当于char[]字符数组

创建方法
1.public String（）创建一个空白字符串
2.public String（char[] array）根据字符串数组内容，创建对应的字符串
3.public String（byte[] array）根据字节数组内容，创建对应的字符串 直接创建 String str=“hello”;

---

字符串常量池：双引号写出的字符串在字符串常量池中，new的不在常量池中

• 对于基本类型 ==是比较数值
• 对于引用类型 ==比较地址值

字符串比较
public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。

public boolean equalsIgnoreCase (String anotherString)将此字符串与指：定对象进行比较，忽略大小 写。 推荐使用"adb".equals(str),否则可能会出现空指异常

public int length () ：返回此字符串的长度。

public String concat (String str) ：将指定的字符串连接到该字符串的末尾。

public char charAt (int index) ：返回指定索引处的 char值。

public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。

public String substring (int beginIndex)：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。

public String substring (int beginIndex, int endIndex)：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。

public char[] toCharArray () ：将此字符串转换为新的字符数组。

public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。

public String replace (CharSequence target, CharSequence replacement)：将与target匹配的字符串使 用replacement字符串替换

分割功能的方法
public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组，如果应".“进行切分,必须写”\."

1.5 static 静态关键字

• static关键字，内容将属于类，本类对象共享内容

• static修饰成员变量，那么这个变量不在属于自己，而是属于所在的类，多个对象共享同一份数据类名.静态变量

• static修饰成员方法，静态方法不属于对象而属于类，对于静态方法使用类名.静态方法名调用

• 对于本类当中的静态方法，可以省略类名称

• 静态只能直接访问静态，不能直接访问非静态

• 成员方法可以访问成员变量和静态变量

• 静态方法可以访问静态变量，不能访问非静态变量，不能使用this关键字

静态代码块  
public class ClassName{
static {
// 执行语句
}
}  

随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。

Arrays 数组工具类 .

1. public static String toString(int[] a) ：返回指定数组内容的字符串表示形式。

2. public static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。 math工具类

3. public static double abs(double a) ：返回 double 值的绝对值。 public static

4. double floor(double a) ：返回小于等于参数最大的整数，向下取整

5. public static double ceil(double a) ：返回大于等于参数最大的整数，向上取整

6. public static long rou-nd(double a) ：返回最接近参数的- long。(相当于四舍五入方法)

---

2继承

继承，共性抽取

2.1 继承的格式

class 父类 {
...
}
class 子类 extends 父类 {
...
}  

• 父类只能访问父类内容
• 子类可以访问父类和子类内容

2.1.1 区分子类方法中重名三种：

1. 局部变量 直接写
2. 本类的成员变量：this.成员变量名
3. 父类的成员变量：super.父类成员变量

2.1.2 继承成员变量的访问特点:

1. 直接通过子类对象访问成员变量。等号左边是谁就优先用谁，没有则向上找。
2. 间接通过成员方法访问成员变量： 该方法属于谁，就优先用谁，没有则向上找。

继承中成员方法的访问特点： 创建new的对象是谁，就优先用谁，没有则向上找

• override 重写 覆盖 方法名一样，参数列表也一样
• overload 重载 方法名一样，参数列表不一样

方法的覆盖重写特点 ，创建的子类对象，则优先永子类方法。

覆盖重写注意：

1. 父子类方法名相同，参数列表也相同 方法前加注解@override可检测是否正确重写
2. 子类的方法返回值必须小于等于父类方法的返回值范围
3. 子类方法的权限必须【大于等于】父类方法的权限修饰符。 pub》pro>default>pri

继承中构造方法的访问特点：

1. 子类构造方法当中有一个默认隐含是的super(),所以先调用父类构造，后执行子类构造。
2. 可以通过super()关键字来子类构造调用父类重载构造。
3. super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。 子类必须调用父类构造，不写则赠送super（）；写了则用写的指定super调用

super关键字的用法：

1. 在子类成员方法中，访问父类的成员变量
2. 在子类的成员方法中，访问父类方法。
3. 在子类的构造方法中，访问父类构造方法

this关键字的三种用法：用来访问本类内容：

1. 在本类成员方法中访问本类成员变量
2. 在本类的成员方法中，访问本类的另一个成员方法
3. 本类的构造方法中，访问另一个构造方法this调用也必须是构造方法的第一个语句，也就是唯一一个。
   super和this两种构造调用，不能同时使用。

• Java是单继承的，一个类的直接父类只能有一个
• Java可以多级继承。一个父类可以有多个子类

---

3 抽象类

如果父类的方法不确定如何进行{}方法体实现，此为抽象方法。

定义格式

加上abstract关键字，去掉大括号。直接分号结束。

抽象类：在class之前加abstract

抽象方法和抽象类的使用

1. 不能直接new创建抽象类对象。
2. 必须使用子类继承抽象父类
3. 子类必须覆盖重写抽象父类中的抽象方法。（覆盖重写：子类去掉抽象方法的abstract关键字，不上方法体大括号）
4. 创建子类对象进行使用

注意：

1. 抽象类中可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

2. 抽象类中，不一定包含抽象方法，但有抽象方法一定是抽象类。

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

---

4.接口

多个类公共规范，是一种引用数据类型，主要为抽象方法。

java8包含的内容有： (9(8（7常量，抽象方法），默认方法，静态方法)，私有方法)

• 接口中的抽象方法必须是两个固定的关键字public abstract ，可省略

• 接口不能直接使用，必须使用实现类
  public class 实现类名 implements{}

• 接口的实现必须覆盖重写接口中的所有抽象方。

• 实现类没有覆盖重写接口中所有抽象方法，那这实现类就是抽象类

接口的默认方法定义：解决接口升级问题
public defualt 返回值类型   方法名（参数列表）{ 方法体}

新添加的接口 新添加为改为默认方法： default void 方法名(){}

• 接口的默认方法可以直接通过接口实现类调用。
• 接口的默认方法，也可以被接口实现类进行覆盖重写

静态方法：
public static 返回值类型 方法名称（参数列表）{方法体} 就是将abstract 或 default 换成static 即可 带上方法体 ！！
不可以通过接口实现类对象来调用接口中的静态方法。
正确方法：通过接口名称，直接调用其中的静态方法，
格式：接口名称.静态方法名（参数）。

抽取接口中默认方法的重复代码为一个共有方法，这个共有方法不应让实现类使用，应该是私有化的。

在Java9中接口中定义私有方法：

1. 普通私有方法解决多个默认方法之间重复代码问题。
   格式：
   private 返回值类型 方法名称（）{}
2. 静态私有方法，解决多个静态方法之间的重复代码问题。

格式：
private static 返回值类型 方法名（）{}

• Java常量定义和使用： 必须使用public static final 三个关键词修饰 ，可省略，其实是一个常量，一旦赋值，不可修改。
• 必须手动进行赋值。！！ 需全部大写，用下划线进行分隔

注意：

1. 接口中不能有静态代码块，不能有构造方法。

2. 一个类的直接父类是唯一的，一个类可以实现多个接口。 格式： public class MyInterfaceImpl implements MyInterfaceA,MyIterfaceB{覆盖重写所有的抽象方法}

3. 如果实现类所实现的多个接口中，存在重复的抽象方法，那么只需要重写一次即可。

4. 如果实现类没有全部重写抽象类中的抽象方法，那么此类必须是一个抽象类

5. 如果实现类实现的多个接口当中，存在重复的默认方法，那么实现类必须重写其重复的默认方法

6. 一个类中的直接父类中方法和实现接口中的方法重复，优先使用父类中的方法。

接口间的多继承：
1.类与类之间是单继承的。直接父类只有一个。
2.类与接口之间是多实现的，一个类可以实现多个接口。
3.接口与接口之间是多继承的。 多个接口中的抽象方法可以重复，若默认方法重复，那么子接口必须进行默认方法的覆盖重写（带着default关键字）。

5.多态性

父类引用指向子类对象。

• 多态中成员变量的使用特点同继承。 口诀：编译看左边，运行看左边

• 多态中成员方法的使用特点同继承。口诀：编译看左边，运行看右边

多态的好处

• 向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。

使用格式：
父类类型 变量名 = new 子类类型(); 如：Animal a = new Cat();

• 向下转型 向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

使用格式：
子类类型 变量名 = (子类类型) 父类变量名; 如:Cat c =(Cat) a;

！！不能调用子类拥有，而父类没有的方法

变量名 instanceof (数据类型 )
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。

示例：
public class Test {
public static void main(String[] args) {
// 向上转型
Animal a = new Cat();
a.eat(); // 调用的是 Cat 的 eat
// 向下转型
if (a instanceof Cat){
Cat c = (Cat)a;
c.catchMouse(); // 调用的是 Cat 的 catchMouse
} else if (a instanceof Dog){
Dog d = (Dog)a;
d.watchHouse(); // 调用的是 Dog 的 watchHouse
}
}
}

---

6. final关键字

代表不可改变的

四种用法：

1. 类
   public final class 类名 {} 这个类不能有任何子类

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

   这个方法不能被覆盖重写，对于类和方法类型，abstract 和final 关键字不能同时使用，矛盾

3. 局部变量
   final 修饰局部变量 ，那么这个变量无法更改。 一次赋值，终身不变
   不可变对于基本类型，变量中数据不可变。 对于引用类型，不可变为地址值不可变。

4. 成员变量
   对于成员变量，使用final关键字修饰，变量不可变，必须手动赋值。 要么使用直接赋值，要么通过构造方法赋值。 必须保证类当中的所有构造方法，都最终会对final的成员变量赋值。

权限修饰符

public 同一个类 （我自己） 全都可以访问

protected 同一个包 （我邻居） 只有private 不可以访问

default 不同包子类 （我儿子） default和 private不可访问

private不同包非子类 （陌生人） 只有public 可以访问

---

7. 内部类

7.1 成员内部类

定义格式：
修饰符  class  外部类名称{
修饰符 class   内部嘞名称{
}
}

注意，内用外，随意访问，外用内，需要内部类对象。

如何使用成员内部类》？
1.间接方式 在 外部类 的方法中调用内部类，然后main只是调用外部类的方法。

通过外部类的对象，调用外部类的方法，间接使用内部类

2.直接方式 公式：外部类名称.内部类名称 对象名 =new 外部类名称（).new 内部类名称（）；

内部类的同名变量访问：
1.内部类方法的局部变量：直接使用，就近原则。
2.内部类的成员变量：this.变量名。
3.外部类的成员变量：外部类名称.this.外部类成员变量。

7.2 局部内部类

• 局部内部类：如果一个类定义在一个方法内部的，那么这就是一个局部内部类。
• “局部”：只有当前所属的方法才能使用它，除了这个方法外边就不能用了。

定义格式：
修饰符  class  外部类名称{
   修饰符  返回值类型  外部类方法名称 （参数列表）{
   class  局部内部类名称{
}
}
}

使用：
创建好inner 对象，使用inner对象调用method inner

定义一个类的权限修饰符：

1. 外部类：public /default
2. 成员内部类：四个都可以
3. 局部内部类：什么都不能写

局部内部类final问题

局部变量如果希望访问所在方法的局部变量，那么这个局部变量必须是（有效final的）
java8开始局部变量在变量事实不变的情况下，可省略不写final

7.3 匿名内部类：

如果接口的实现类，或者父类的子类，只需要使用一次，这种情况可以省略该类的定义，而改为使用匿名内部类。

定义格式：
接口名    对象名  =new   接口名（）{
覆盖重写所有抽象方法
}

1. new 代表创建对象的动作，
2. 接口名称就是匿名内部类需要实现那个接口
3. {。。。}为匿名内部类的内容

注意事项：

1. 匿名内部类在创建对象的时候，只能使用唯一的一次； 如果希望多次创建对象，必须使用单独的实现类。
2. 匿名对象，在调用方法时候只能调用唯一一次，如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
3. 匿名内部类省略了（实现类/子类名称），匿名对象省略（对象名称）。两个不是一会事。

接口作方法的参数和返回值。