泛型
泛型定义
在一个类型（类，接口，方法）之后，定义一个类型参数。
原生类型:类型后面没有指定具体的类型参数。
好处
使用泛型的好处在于，它在编译的时候进行类型安全检查，并且在运行时所有的转换都是强制的，隐式的，大大提高了代码的重用率。
语法
class Point<T>{}
通配符（？）
*通配符（？）可以接受任何的类类型。
public void show(Point<?> p){}
（? extends 上限类）只能接受上限类和上限类子类，如只能接受数字类型，Byte,Short,Integer,Long,Float,Double
public void show(Point<? extends Number> p){}
（? super 下限类）下限，下限类和下限类的父类，Number和Number的父类
public void show(Point<? super Number> p){}
注意
Point<Object>不是Point<String>、Point<Integer>等的父类
public void add(Point<String> ps,Point<Object> po){//错误
po = ps
}
public void add(Point<String> ps,Point<? extends Object> po){//正确
类型参数与通配符的区别
类型参数与 通配符的区别：
<T> 和 <?>
1.类型参数可以指定上限，也只能指定上限；
统配符可以指定上限，也可以指定下限；
2.类型参数 可以指定多个 上限；
通配符 只能指定一个上限；
3.类型参数 可以作为一种类型存在；
统配符不能表示 类型
泛型构造
//定义了一个泛型类
class PointN<T>{//类型参数 形式类型参数
private T x;
private T y;
//定义了一个泛型构造器
<E>PointN(E e){
System.out.println(e);
}
public T getX() {
return x;
}
public void setX(T x) {
this.x = x;
}
public T getY() {
return y;
}
public void setY(T y) {
this.y = y;
}
}
public class TestPoint2 {
public static void main(String[] args) {
// 指定具体的类型参数
PointN<String> p1 = new <Integer>PointN<String>();
//类型推断： 根据参数 的类型 自动推断出 构造的类型参数 是Integer类型
PointN<String> p2 = new PointN<String>();
} }
泛型方法
定义泛型方法时，必须在返回值前边加一个<T>，来声明这是一个泛型方法，持有一个泛型T，然后才可以用泛型T作为方法的返回值。
class Demo{
//泛型方法
public <E> void f(E e) {
System.out.println(e);
}
public <E> E ff(E e) {
return e;
}
public <E extends Number> void fff(E e) {
System.out.println(e);
//自动推断的方式
f("hello");
//指定的方式，显示，this
this.<String>f("hello");
}
}
public class TestPoint3 {
public static void main(String[] args) {
// 泛型方法应用
Demo d = new Demo();
//具体指定 泛型方法参数的类型
d.<String>f("hello");
//可以使用类型推断： 根据参数的类型 自动推断
d.f();
d.fff();
}
}
泛型擦除
1.参数化类型：Point<String>，擦除后为原生类型Point
2.类型参数:用上界来替换
Point<T>:*类型参数，用Object来替换
类型参数有上限，用上限来替换。
有多个上限，用第一个上限替换。
重载
class PointNew<T>{}
interface Info1{}
interface Info2{}
class Demo1{
//为了实现重载
//生成的字节码文件中，泛型的信息被擦除了
public void f(String p) {}
public void f(PointNew<Integer> p) {}//擦除后:PointNew p
public <E> void f(E e) {}//擦除后:Object e
public <E extends Info1> void f(E e) {}//擦除后:Info1 e
public <E extends Info2 & Info1> void f(E e) {}//擦除后:Info2 e
}
重写
class Parent{
//重写：参数父类中参数擦除后与子类中参数相同
public void f(PointNew<String> p) {}
}
class Child1 extends Parent{
public void f(PointNew<String> p) {}
}
泛型接口
//泛型接口
interface Info<T>{
void f(T t);
}
//在实现接口时 指定具体的类型参数
class InfoImpl1 implements Info<String>{
@Override
public void f(String t) {
System.out.println(t);
}
}
//在实现 接口时 不能确定类型
class InfoImpl2<T> implements Info<T>{
@Override
public void f(T t) {
System.out.println(t);
}
}
public class TestPoint5 { public static void main(String[] args) {
InfoImpl1 i1 = new InfoImpl1();
i1.f("hello");
InfoImpl2<String> i2 = new InfoImpl2<>();
i2.f("tom");
} }
比较器
Comparable
Comparator
对象进行自然方式排序，必须是实现了Comparable接口的。
Arrays.sort(数组);//默认 自然排序
Comparable<T> 泛型接口 比较器实现自然排序
Comparator<T> 泛型接口 外部比较器
package day13; import java.util.Arrays;
import java.util.Comparator;
class Student implements Comparable<Student>{
private int age;
private int no;
public Student(int no,int age) {
this.age = age;
this.no= no;
}
public int getAge() {
return age;
}
public int getNo() {
return no;
}
@Override
public String toString() {
return "编号："+no+",年龄："+age;
}
/* @Override
public int compareTo(Object o) {
//this 与 o比较
//this.age o.age
Student stu = (Student)o;
//this.age stu.age return 0;
}*/
@Override
public int compareTo(Student o) {
// this.age o.age
//升序的方式
/*if(this.age > o.age ) {
return 1;//正数
}else if(this.age < o.age) {
return -1;//负数
}else {
return 0;//相等
}*/
return this.age - o.age;
}
}
//按照 编号升序排序
class NoComparator implements Comparator<Student>{
@Override
public int compare(Student o1, Student o2) {
// o1 和 o2比较
/* if(o1.getNo() > o2.getNo()) {
return 1;
}else if(o1.getNo() < o2.getNo()) {
return -1;
}else {
return 0;
}*/
return o1.getNo()- o2.getNo();
}
}
public class TestSort {
public static void main(String[] args) {
Student zhang = new Student(,);
Student wang = new Student(,);
Student zhao = new Student(,);
Student [] stus = {zhang,wang,zhao};
//Arrays.sort()按照自然方式排序的
// Arrays.sort(stus);
//1.自定义类 实现接口
// Arrays.sort(stus, new NoComparator());
//2.匿名内部类实现接口
Arrays.sort(stus,new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getNo() - o2.getNo();
}
});
//3 Lambda
Arrays.sort(stus,(s1,s2)->s1.getNo()-s2.getNo()); Arrays.stream(stus).forEach(System.out::println);
//--------------------------------------------
int [] arr = {,,,,};
Arrays.sort(arr);
Arrays.stream(arr).forEach(System.out::println);
//--------------------------------------------
String [] arrs = {"cc","dd","aa","ee"};
Arrays.sort(arrs);
Arrays.stream(arrs).forEach(System.out::println);
//------------------------------------------------
} }
枚举类型
语法
enum 枚举类型{
}
package day13; import java.util.Scanner; //RGB
/*class Color{
public static final int RED = 1;
public static final int GREEN = 2;
public static final int BLUE = 3;
}*/
interface ColorInfo{
void fv();//抽象方法
}
enum Color{
RED(,"红色") {
@Override
void f() {
// TODO Auto-generated method stub }
},GREEN(,"绿色") {
@Override
void f() {
// TODO Auto-generated method stub }
},BLUE(,"蓝色") {
@Override
void f() {
// TODO Auto-generated method stub }
}; private Color(int no, String name) {
this.no = no;
this.name = name;
}
private int no;
private String name;
//抽象方法
abstract void f();
}
/*enum Color implements ColorInfo{
//定义枚举成员,对象，实例
RED(1,"红色"){
public void fv() {
System.out.println("红色的");
}
},GREEN(2,"绿色"){
public void fv() {
System.out.println("绿色的");
}
},BLUE(3,"蓝色"){
public void fv() {
System.out.println("蓝色的");
}
}; //public static final
private int no;//编号
private String name;//名字 private Color(int no, String name) {
this.no = no;
this.name = name;
}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void f() {}
@Override
public String toString() {
// TODO Auto-generated method stub
return this.no+","+this.name();
}
@Override
public void fv() {
// TODO Auto-generated method stub } }*/
public class TestEnum {
public static void main(String[] args) {
// System.out.println(Color.RED.getNo()+","+Color.RED.getName());
// System.out.println(Color.BLUE.getNo()+","+Color.BLUE.getName());
/* Color.RED.setName("红色");
System.out.println(Color.RED.getName());
Color.RED.f();*/
/* Color.RED.no = 11;
Color.GREEN.name = "绿色";
System.out.println(Color.RED.no);
System.out.println(Color.GREEN.name);*/ /* Scanner input = new Scanner(System.in);
System.out.println("输入一个颜色：");
String s = input.next();
Color co = Color.valueOf(s);
switch(co) {
case RED:
System.out.println("进行红色的操作");
break;
case GREEN:
System.out.println("进行绿色的操作");
break;
case BLUE:
System.out.println("进行蓝色的操作");
break;
}*/ //可以遍历枚举值
/* for(Color c: Color.values()) {
System.out.println(c.name());
System.out.println(c.ordinal());
}*/ /* // 类型不安全
int red = Color.RED;
int a = red +5;
System.out.println(a);
//意思不明确
System.out.println(Color.RED);*/
// System.out.println(Color.RED); } }
注意
1.所有的枚举类型的对象都在枚举类第一行显示定义出来。
2.对象默认是public static final的
3.枚举类的构造都是private的
4.枚举类继承自java.lang.Enum类
5.对于一个非抽象枚举类来说，都是final
一个枚举类的所有对象都实现了接口中的抽象方法，此枚举类就是抽象类，abstract的了
枚举类中定义抽象abstract方法，所有对象都需要实现此抽象方法，那么此枚举类是abstract的了
强制垃圾回收
class Person{
@Override
protected void finalize() throws Throwable {
System.out.println("this---->"+this);
}
}
public class TestGC {
public static void main(String[] args) {
// 强制垃圾回收
Person per = new Person();
System.out.println(per);
per = null;//断开引用
System.gc();//强制通知垃圾回收器
// Runtime.getRuntime().gc();//
}
}