这里是本人学习JavaSE进阶的学习总结,记录一下。
多个对象需要共享同一个数据
public static 数据类型 变量名;
public static String country;//国籍
类名.属性名 【推荐】
Chinese.country = "中国";
对象名.属性名
Chinese c1 = new Chinese();
c1.country;
由static修饰的方法
public static void staticMethod(){
System.out.println("静态方法");
}
如果方法中没有使用到成员变量,就可以使用静态方法,不用创建对象,直接调用
类名.方法名() 【推荐】
MethodDemo01.staticMethod();
对象名.方法名()
MethodDemo01 d1 = new MethodDemo01();
d1.method();
静态只能调用静态的成员
非静态的方法可以调用静态和非静态的成员
步骤
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);
}
}
如果多个类有共同的属性和行为,我们就可以抽取这些共性数据到一个类中 【父类】
public class 子类 extends 父类{}
访问的时候,根据就近原则去访问,先从方法找,找不到就从当前类中去找,如果还是找不到就从父类中找,如果还是找不到就出错。
this.变量
本类中的成员变量
super.变量
父类中的成员变量
访问的时候,根据就近原则去访问,先从当前类中去找方法,如果还是找不到就从父类中找,如果还是找不到就出错
this.方法名()
本类中方法
super.方法名()
父类的方法
注意:子类的构造方法,默认第一行去调用父类的构造方法,super();
super(…) 调用父类的有参构造
this() 调用本类的无参构造
this(…) 调用本类中的有参构造
特点
常用实现类
常用方法
特点
常用实现类
下章了解
执行: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)];
}
}
参数的个数不确定时,设计为可变参数
数据类型 … 变量
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;
}
修饰符 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();
}
}
修饰符 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");
修饰符 <泛型标记> 返回值类型 方法名(类型 变量名) { }
//定义方法,打印任意类型数组 [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);
> 通配符
//当使用泛型的时候,无法确定泛型的具体类型时,可以使用通配符 ? 来表示某一种类型。
//> 通配符 什么类型都可以匹配,范围太大
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){
}
有索引,有顺序,可重复
代码写的越急,程序跑得越慢。—— Roy Carlson