Java入门学习总结 4月28日

Object类与常用API

toString方法

• 返回对象的类型@内存地址
• 覆盖重写

equals方法

• 比较地址值
• 覆盖重写

Objects类

• public static boolean equals(Object a, Object b):判断两个对象是否相等。

日期时间类

Date类

• 构造器：public Date() public Date(long date)
• public long getTime() 把日期对象转换成对应的时间毫秒值。

DateFormat类

 DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
 //DateFormat为抽象类，用多态的方法创建对象	
 // 并且构造参数并不是一个具体的日期，
 //而是定义一个具体的格式，
 //告诉你我的对象（模具是这个形状的）是这个格式的
 String str = "2018年12月11日";
 Date date = df.parse(str);//注：解析字符串只能解析调用parse方法的对象的日期相同构造格式的字符串
   //df模具有了，你要parse字符串，必须放的进来我模具的形状里，我才能给你还原成日期对象
 - 

Calendar类

• public static Calendar getInstance()：使用默认时区和语言环境获得一个日历

 {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        //调用静态方法获得对象实例
    }    
}

• get/set方法 ：get方法用来获取指定字段的值，set方法用来设置指定字段的值
• Calendar本身有很多静态实例，如YEAR,MONTH等，而cal这个对象实例有get,set方法，不用刻意去记忆，idea会提示，用多了就记得了
• Date date = cal.getTime(); 该方法比较特殊，可以返回一个Date对象实例

System类

• currentTimeMillis方法

  //获取当前时间毫秒值
    System.out.println(System.currentTimeMillis());

StringBuilder类

• 字符串拼接时不建议使用 + ，建议使用StringBuilder类
• 构造器：StringBuilder sb1 = new StringBuilder(); //空参 StringBuilder sb2 = new StringBuilder(“itcast”); //有参字符串
• 常用方法：public StringBuilder append(…)`：添加任意类型数据的字符串形式，并返回当前对象自身。
  public String toString()：将当前StringBuilder对象转换为String对象。

包装类

• 基本类型如下如何拆箱：parseXXX方法

 int num = Integer.parseInt("100");	//Integer类的静态方法parseXxx为例,其他包装类要拆箱也仿照这个格式

• 基本类型如何装箱：Integer.valueOf(int a) 方法

Integer i = new Integer(4);//使用构造函数函数
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法

泛型

定义和使用含有泛型的类

定义格式：

修饰符 class 类名<代表泛型的变量> {  }

例如，API中的ArrayList集合：

class ArrayList<E>{ 
    public boolean add(E e){ }

    public E get(int index){ }
   	....
}

使用泛型： 即什么时候确定泛型。

在创建对象的时候确定泛型

例如，ArrayList<String> list = new ArrayList<String>();

此时，变量E的值就是String类型,那么我们的类型就可以理解为：

class ArrayList<String>{ 
     public boolean add(String e){ }

     public String get(int index){  }
     ...
}

再例如，ArrayList<Integer> list = new ArrayList<Integer>();

此时，变量E的值就是Integer类型,那么我们的类型就可以理解为：

class ArrayList<Integer> { 
     public boolean add(Integer e) { }

     public Integer get(int index) {  }
     ...
}

举例自定义泛型类

public class MyGenericClass<MVP> {
	//没有MVP类型，在这里代表 未知的一种数据类型 未来传递什么就是什么类型
    //普通类和泛型类一样，都可以通过我们自己来写，来定义，只是泛型类需要一个尖括号运算符，里面放whataver都可以，在创建的时候指定具体类就行了
	private MVP mvp;
     
    public void setMVP(MVP mvp) {
        this.mvp = mvp;
    }
     
    public MVP getMVP() {
        return mvp;
    }
}

使用:

public class GenericClassDemo {
  	public static void main(String[] args) {		 
         // 创建一个泛型为String的类
         MyGenericClass<String> my = new MyGenericClass<String>();    	
         // 调用setMVP
         my.setMVP("大胡子登登");
         // 调用getMVP
         String mvp = my.getMVP();
         System.out.println(mvp);
         //创建一个泛型为Integer的类
         MyGenericClass<Integer> my2 = new MyGenericClass<Integer>(); 
         my2.setMVP(123);   	  
         Integer mvp2 = my2.getMVP();
    }
}

含有泛型的方法

定义格式：

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

例如，

public class MyGenericMethod {	  
    public <MVP> void show(MVP mvp) {
    	System.out.println(mvp.getClass());
    }
    
    public <MVP> MVP show2(MVP mvp) {	
    	return mvp;
    }
}

使用格式：调用方法时，确定泛型的类型

public class GenericMethodDemo {
    public static void main(String[] args) {
        // 创建对象
        MyGenericMethod mm = new MyGenericMethod();
        // 演示看方法提示
        mm.show("aaa");
        mm.show(123);
        mm.show(12.45);
    }
}

含有泛型的接口

定义格式：

修饰符 interface接口名<代表泛型的变量> {  }

例如，

public interface MyGenericInterface<E>{
	public abstract void add(E e);
	
	public abstract E getE();  
}

使用格式：

1、定义类时确定泛型的类型

例如

public class MyImp1 implements MyGenericInterface<String> {
	@Override
    public void add(String e) {
        // 省略...
    }

	@Override
	public String getE() {
		return null;
	}
}

此时，泛型E的值就是String类型。

2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型

例如

public class MyImp2<E> implements MyGenericInterface<E> {
	@Override
	public void add(E e) {
       	 // 省略...
	}

	@Override
	public E getE() {
		return null;
	}
}

确定泛型：

/*
 * 使用
 */
public class GenericInterface {
    public static void main(String[] args) {
        MyImp2<String>  my = new MyImp2<String>();  
        my.add("aa");
    }
}

通配符高级使用----受限泛型

之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。

泛型的上限：

• 格式： 类型名称 <? extends 类 > 对象名称
• 意义： 只能接收该类型及其子类

泛型的下限：

• 格式： 类型名称 <? super 类 > 对象名称
• 意义： 只能接收该类型及其父类型

比如：现已知Object类，String 类，Number类，Integer类，其中Number是Integer的父类

public static void main(String[] args) {
    Collection<Integer> list1 = new ArrayList<Integer>();
    Collection<String> list2 = new ArrayList<String>();
    Collection<Number> list3 = new ArrayList<Number>();
    Collection<Object> list4 = new ArrayList<Object>();
    
    getElement(list1);
    getElement(list2);//报错
    getElement(list3);
    getElement(list4);//报错
  
    getElement2(list1);//报错
    getElement2(list2);//报错
    getElement2(list3);
    getElement2(list4);
  
}
// 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll){}
// 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}

Comparator比较器

如果在使用的时候，想要独立的定义规则去使用 可以采用Collections.sort(List list,Comparetor c)方式，自己定义规则：

//本质：sort方法后面有两个参数，一个是要排序的对象，
//另一个就是new出来的(可能带泛型的)比较器了，而自定义排序的本质就是重写compare方法，
//方法参数是对象中的单个实例（前者是前面的实例，后者是后面的实例）
//本质：返回负数的方式排序，如下o2 < o1才能返回负数

Collections.sort(list, new Comparator<Student>() {
    @Override
    public int compare(Student o1, Student o2) {
        return o2.getAge()-o1.getAge();//以学生的年龄降序
    }
});