JavaSE学习笔记

---

前言

这里是本人学习JavaSE进阶的学习总结，记录一下。

---

一、static、继承、权限修饰符

---

1.静态(static)

1.1.静态成员变量

1.1.1.应用场景

多个对象需要共享同一个数据

1.1.2.定义格式

public static 数据类型 变量名;

 public static String country;//国籍

1.1.3.使用格式

类名.属性名 【推荐】

Chinese.country = "中国";

对象名.属性名

Chinese c1 = new Chinese();
c1.country;

1.2.静态方法

1.2.1.概念

由static修饰的方法

public static void staticMethod(){
	System.out.println("静态方法");
}

1.2.2.使用场景

如果方法中没有使用到成员变量，就可以使用静态方法，不用创建对象，直接调用

1.2.3.使用格式

类名.方法名() 【推荐】

	MethodDemo01.staticMethod();

对象名.方法名()

	MethodDemo01 d1 = new MethodDemo01();
    d1.method();

1.2.4.注意事项

静态只能调用静态的成员
非静态的方法可以调用静态和非静态的成员

1.3.工具类

步骤

1. 私有构造方法
2. 方法有static修饰

public class CodeUtils { //验证码的工具类

    private CodeUtils(){
    }
    //需要把构造方法是有
    public static String getCode(int length){
        //生成是6个数字  0 ~ 9
        Random r = new Random();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < length; i++) {
            int a = r.nextInt(10);
            sb.append(a);
        }
        String code = sb.toString();
       // System.out.println("生成的验证码为：" + code);
        return  code;
    }

    public static  void method(){
        getCode(10);

    }
}

2.继承

2.1.继承的作用

如果多个类有共同的属性和行为，我们就可以抽取这些共性数据到一个类中 【父类】

2.2.继承的格式

public class 子类 extends 父类{}

2.3.继承的特点

1. Java是单继承，不支持多继承
2. Java支持多层继承
3. 私有数据可以被继承到子类中，但是不能使用
4. 构造方法不能被继承

2.4.继承之后成员变量的访问

访问的时候，根据就近原则去访问，先从方法找，找不到就从当前类中去找，如果还是找不到就从父类中找，如果还是找不到就出错。

this.变量
本类中的成员变量

super.变量
父类中的成员变量

2.5.继承之后成员方法的访问

访问的时候，根据就近原则去访问，先从当前类中去找方法，如果还是找不到就从父类中找，如果还是找不到就出错

this.方法名()
本类中方法

super.方法名()
父类的方法

2.6.继承之后构造方法的访问

注意：子类的构造方法，默认第一行去调用父类的构造方法，super();

super(…) 调用父类的有参构造

this() 调用本类的无参构造

this(…) 调用本类中的有参构造

3.权限修饰符

二、final、抽象类、接口

三、多态、Object类、内部类、枚举

四、常用API、正则表达式

五、数据结构、List集合、泛型和可变参数

---

1.集合体系

1.1.单列集合 Collection接口

1.1.1.List接口

特点

1. 有序（存和取顺序一样）
2. 可重复
3. 有索引

常用实现类

1. ArrayList
   查询快，增删慢
2. LinkedList
   查询慢，增删快

常用方法

1.1.2.Set接口

特点

1. 无序
2. 不重复
3. 无索引

常用实现类

1. HashSet
2. TreeSet

1.2.双列集合Map接口

下章了解

2.数据结构

2.1.栈

2.2.队列

2.3.数组

2.4.链表

2.5.树

2.5.1.二叉树

2.5.2.平衡二叉树

2.5.3.二叉查找树

2.5.4.红黑树

3.ArrayList的底层

执行：ArrayList list = new ArrayList<>();

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

执行：ArrayList list = new ArrayList<>(20);

  public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

如果已经超过初始元素个数，就要扩容

 private Object[] grow(int minCapacity) {
        int oldCapacity = elementData.length;
        if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            int newCapacity = ArraysSupport.newLength(oldCapacity,
                    minCapacity - oldCapacity, /* minimum growth */
                    oldCapacity >> 1           /* preferred growth */);
            return elementData = Arrays.copyOf(elementData, newCapacity);
        } else {
            return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
        }
    }

4.可变参数

4.1.使用场景

参数的个数不确定时，设计为可变参数

4.2.格式

数据类型 … 变量

	getSum(1,2,3,4);

    //方法参数类型是int，参数的数量可以是任意的
    //可变参数本质就是数组
    public static int getSum(int... arr){
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }

4.3.注意

1. 可变参只能有一个
2. 可变参只能放到最后

5.泛型

5.1.泛型类

5.1.1.定义格式

修饰符 class 类名<泛型标记> { }

	/*
    <类型标记> 代表某一种数据类型，比如：
    <T>  T可以当做某种数据类型，可以出现数据类型的地方，就可以使用T去代替
	*/
    //创建对象的时候确定泛型的类型
	public class Box<T> {
	
	    private T value;
	
	    public T getValue() {
	        return value;
	    }
	
	    public void setValue(T value) {
	        this.value = value;
	    }
	}

	public class Test {
	    public static void main(String[] args) {
	
	        Box<String> b1 = new Box<>();
	        b1.setValue("hello");
	        String v1 = b1.getValue();
	
	
	        Box<Integer> b2 = new Box<>();
	        b2.setValue(12);
	        Integer v2 = b2.getValue();
	
	
	    }
	}

5.1.2.泛型类的作用

1. 泛型类在创建对象时确定泛型的真实类型。
2. 类中引用到泛型的地方都会替换成具体类型。

5.2.泛型接口

5.2.1.定义格式

修饰符 interface 接口名<泛型标记> { }

	//泛型接口

	//实现接口时，确定泛型的类型
	public interface MyList<E> {
	
	    void add(E e);
	
	}

使用1

public class MyArrayList implements MyList<Double>{
    @Override
    public void add(Double s) {
        System.out.println("添加 " + s);
    }
}

	MyArrayList list = new MyArrayList();
	list.add(11.0);

使用2

public class MyArrayList2<T> implements MyList<T>{
    @Override
    public void add(T t) {
        System.out.println("添加 " + t);
    }
}

	MyArrayList2<String> list2 = new MyArrayList2<>();
	list2.add("hello");

5.2.2.泛型接口的作用

1. 实现类实现接口时确定泛型。
2. 接口中引用泛型的地方会替换成具体类型。

5.3.泛型方法

修饰符 <泛型标记> 返回值类型 方法名(类型 变量名) { }

5.3.1.定义格式

  //定义方法，打印任意类型数组 [11, 22, 33, 44]
  //泛型方法，泛型值必须是引用数据类型
  public static <T> void printArray(T[] arr) {
      System.out.print("[");
      for (int i = 0; i < arr.length; i++) {
          if (i == arr.length - 1) {
              System.out.print(arr[i]);
          } else {
              System.out.print(arr[i] + ", ");
          }
      }
      System.out.println("]");
  }

	Integer[] arr = {11, 22, 33, 44};
	printArray(arr);

5.3.2.泛型方法的作用

1. 调用方法，传参时确定泛型类型。
2. 方法中引用泛型的地方会替换成具体类型。

5.4.泛型通配符

<?> 通配符

 //当使用泛型的时候，无法确定泛型的具体类型时，可以使用通配符 ? 来表示某一种类型。
 //<?> 通配符 什么类型都可以匹配，范围太大
 public static void play(ArrayList<?> list){

 }

类型通配符上下限

 //<? extends Car> 通配的类型必须是Car 或者 Car的子类
public static void play(ArrayList<? extends Car> list){

}

  //<? super Car> 通配的类型必须是Car 或者 Car的父类
public static void play(ArrayList<? super Car> list){

}

六、Set集合、迭代器、Collections工具类

七、Map、图书管理系统、算法

---

1.Collection(单列集合)

1.1.List

1.1.1.特点

有索引，有顺序，可重复

1.2.Set

2.Map

总结

代码写的越急，程序跑得越慢。—— Roy Carlson