JavaSE学习笔记

文章目录

  • 前言
  • 一、static、继承、权限修饰符
    • 1.静态(static)
      • 1.1.静态成员变量
        • 1.1.1.应用场景
        • 1.1.2.定义格式
        • 1.1.3.使用格式
      • 1.2.静态方法
        • 1.2.1.概念
        • 1.2.2.使用场景
        • 1.2.3.使用格式
        • 1.2.4.注意事项
      • 1.3.工具类
    • 2.继承
      • 2.1.继承的作用
      • 2.2.继承的格式
      • 2.3.继承的特点
      • 2.4.继承之后成员变量的访问
      • 2.5.继承之后成员方法的访问
      • 2.6.继承之后构造方法的访问
    • 3.权限修饰符
  • 二、final、抽象类、接口
  • 三、多态、Object类、内部类、枚举
  • 四、常用API、正则表达式
  • 五、数据结构、List集合、泛型和可变参数
    • 1.集合体系
      • 1.1.单列集合 Collection接口
        • 1.1.1.List接口
        • 1.1.2.Set接口
      • 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的底层
    • 4.可变参数
      • 4.1.使用场景
      • 4.2.格式
      • 4.3.注意
    • 5.泛型
      • 5.1.泛型类
        • 5.1.1.定义格式
        • 5.1.2.泛型类的作用
      • 5.2.泛型接口
        • 5.2.1.定义格式
        • 5.2.2.泛型接口的作用
      • 5.3.泛型方法
        • 5.3.1.定义格式
        • 5.3.2.泛型方法的作用
      • 5.4.泛型通配符
  • 六、Set集合、迭代器、Collections工具类
  • 七、Map、图书管理系统、算法
    • 1.Collection(单列集合)
      • 1.1.List
        • 1.1.1.特点
      • 1.2.Set
    • 2.Map
  • 总结


前言

这里是本人学习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.权限修饰符

JavaSE学习笔记_第1张图片

二、final、抽象类、接口

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

四、常用API、正则表达式

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


1.集合体系

JavaSE学习笔记_第2张图片

1.1.单列集合 Collection接口

1.1.1.List接口

特点

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

常用实现类

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

常用方法

JavaSE学习笔记_第3张图片

1.1.2.Set接口

特点

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

常用实现类

  1. HashSet
  2. TreeSet

1.2.双列集合Map接口

下章了解

2.数据结构

2.1.栈

JavaSE学习笔记_第4张图片

2.2.队列

JavaSE学习笔记_第5张图片

2.3.数组

JavaSE学习笔记_第6张图片

2.4.链表

JavaSE学习笔记_第7张图片

2.5.树

2.5.1.二叉树

JavaSE学习笔记_第8张图片

2.5.2.平衡二叉树

JavaSE学习笔记_第9张图片

2.5.3.二叉查找树

JavaSE学习笔记_第10张图片

2.5.4.红黑树

JavaSE学习笔记_第11张图片

3.ArrayList的底层

JavaSE学习笔记_第12张图片
JavaSE学习笔记_第13张图片

执行: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去代替
	*/
    //创建对象的时候确定泛型的类型
	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){

 }

类型通配符上下限

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

}
  // 通配的类型必须是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

你可能感兴趣的:(java)