程序调试:
一、泛型
1.泛型类
泛型:就是参数化类型
//定义
class 类<泛型类型标识>{
}
//应用
类名<具体类> 对象名 = new 类名 <具体类> ();
类型擦除
1.参数化类型–>原生类型
//类型擦除(父类的擦除后和子类的一样)
class Base{
public void f(Point<String>point) throws Exception{}
}
class Sub extends Base{
@Override
public void f(Point point)throws InputMismatchException{}//子类的异常处理不能比父类的范围更大
}
2.类型参数:无界类型参数–>Object类型
class Point<T>{
private T x; //T-->Object
private T y;
}
泛型类
/** 泛型类:T表示一种不确定的引用类型(可以定义多个类型)
* <T>:表示类型参数
*/
class Point<T>{
private T x; //Integer-> x
private T y;
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 TestPoint1 {
public static void main(String[] args) {
Point<Integer> point = new Point<>();
point.setX(11);//int->Integer(自动装箱)->Object(向上类型转换)
point.setY(22);
System.out.println(point.getX()+","+point.getY());//11,22
Point<Double> point1 = new Point<>();
point1.setX(11.1);//double->Double(自动装箱)->Object(向上类型转换)
point1.setY(22.2);
System.out.println(point1.getX()+","+point1.getY());//11.1,22.2
Point<String> point2 = new Point<>();
point2.setX("11");//String->Object(向上类型转换)
point2.setY("22");
System.out.println(point2.getX()+","+point2.getY());//11,22
/** 引用
* 参数化类型:一个类型后边定义一个具体的类型参数(Point<Integer>)
* <具体参数必须是引用数据类型>
* 编译期间会用于类型检查
* 原生类型:一个类型后边没有指定具体的类型参数(Point point3 = new Point();)
* 编译期间不会类型检查
* 定义了原生类型,泛型类没有任何意义
*/
//<>:7.0之后支持自动类型推断( 菱形语法、钻石操作符)
Point<Object> point3 = new Point<>();
point3.setX(11);//int->Integer(自动装箱)->Object(向上类型转换)
point3.setY(22);
Integer x = (Integer) point3.getX();//强制转换
Integer y = (Integer) point3.getY();
System.out.println(x+","+y);
/** 只生成了一个类
* 因为泛型只提供了编译期的类型检查
* 在生成字节码的文件中所有的泛型信息会被擦除掉
*/
System.out.println(point.getClass(+));//class cn.day0712.Point
System.out.println(point1.getClass());//class cn.day0712.Point
System.out.println(point2.getClass());//class cn.day0712.Point
//2.应用(创建对象调用方法)
new TestPoint1().showPoint(point1);
}
//需要指定具体的类型参数(Point<Double> p)
public void showPoint(Point<Double> p) {
System.out.println(p.getX()+":"+p.getY());
}
}
泛型接口
//泛型接口
interface Info<T>{//Type Element
T af(T t);//T表示不确定
}
//实现方式一(实现接口的时候能确定T的类型)
class InfoImpl1 implements Info<String>{
@Override
public String af(String t) {
// TODO Auto-generated method stub
return t;
}
}
//实现方式二(实现接口的时候还是不能确定T的类型)
class InfoImpl2<T> implements Info<T>{
@Override
public T af(T t) {
// TODO Auto-generated method stub
return t;
}
}
public class Demo2 {
public static void main(String[] args) {
InfoImpl1 in1 = new InfoImpl1();
String s1 = in1.af("hello");
System.out.println(s1);//hello
InfoImpl2<Double> in2 = new InfoImpl2<>();
double s2 = in2.af(22.2);
System.out.println(s2);//22.2
}
}
2.通配符
1.(?): 无界通配符,匹配所有的类型
2.(? extengs E):通配符上线,匹配E或者E的子类型
3.(? super E): 通配符下线,匹配E或者E的父类型
/** 泛型类:T表示一种不确定的引用类型(可以定义多个类型)
* <T>:表示类型参数
*/
class Point<T>{
private T x; //Integer-> x
private T y;
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 TestPoint1 {
public static void main(String[] args) {
Point<Integer> point = new Point<>();
point.setX(11);//int->Integer(自动装箱)->Object(向上类型转换)
point.setY(22);
System.out.println(point.getX()+","+point.getY());//11,22
/** 1.(?): 无界通配符,匹配所有的类型
* 2.(? extengs E):通配符上线,匹配E或者E的子类型
* 3.(? super E): 通配符下线,匹配E或者E的父类型
*/
//通配符
new TestPoint1().showPoint(point);
}
public void showPoint(Point<?> p) {//匹配所有的类型
System.out.println(p.getX()+":"+p.getY());
}
}
3.比较器
1.Comparable:是一个泛型接口:
作用: 使得一个类具备排序的能力。(只能进行升序排序)
import java.util.Arrays;
class Student implements Comparable<Student>{
private int no;
private String name;
private int age;
public Student(int no, String name, int age) {
this.no = no;
this.name = name;
this.age = age;
}
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 int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [no=" + no + ", name=" + name + ", age=" + age + "]";
}
@Override
public int compareTo(Student o) {
//this o
/** 升序比较规则:
* this.属性 > o.属性 正数
* this.属性 < o.属性 负数
* this.属性 == o.属性 0
*/
//年龄升序排序
/*if (this.age>o.age) {
return 1;
} else if(this.age<o.age) {
return -1;
}else {
return 0;
}*/
return this.age-o.age
}
}
public class TestComparable {
public static void main(String[] args) {
//数组类型
int [] arr = {11,54,28,36,69};
Arrays.sort(arr);//升序排序
System.out.println(Arrays.toString(arr));//[11, 28, 36, 54, 69]
//引用类型
String [] arrs = {"aa","bb","ee","cc","dd"};
Arrays.sort(arrs);
System.out.println(Arrays.toString(arrs));//[aa, bb, cc, dd, ee]
//------------------------------------------
Student guojing = new Student(1,"郭靖",22);
Student yangkang = new Student(3,"杨康",26);
Student huangrong = new Student(2,"黄蓉",20);
Student [] s = {guojing,yangkang,huangrong};
/** 引用类型都是自然排序
* 都是按照Comparable接口提供的比较方式排序
*/
//自然排序(按Comparable接口的比较方式排序)
Arrays.sort(s);
Arrays.stream(s).forEach(System.out::println);
}
}
2.Comparabtor:是一个函数式泛型接口:
作用: 是一个外部比较器,让用户定义排序顺序。(可以进行升序和降序排序)
import java.util.Arrays;
import java.util.Comparator;
class Student1 implements Comparable<Student1>{
private int no;
private String name;
private int age;
private int score;
public Student1(int no, String name, int age,int score) {
this.no = no;
this.name = name;
this.age = age;
this.score = score;
}
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 int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
@Override
public String toString() {
return "Student [no=" + no + ", name=" + name + ", age=" + age + ", score=" + score + "]";
}
@Override
public int compareTo(Student1 o) {
return this.score-o.score;
}
}
//自定义的比较器(也是实现类)
class MyComparator implements Comparator<Student1>{
@Override
public int compare(Student1 o1, Student1 o2) {
return o1.getAge()-o2.getAge();
}
}
public class TestComparator {
public static void main(String[] args) {
Student1 guojing = new Student1(1,"郭靖",22,96);
Student1 yangkang = new Student1(3,"杨康",26,88);
Student1 huangrong = new Student1(2,"黄蓉",20,98);
Student1 [] s = {guojing,yangkang,huangrong};
//自然排序(按Comparable接口的比较方式排序)
Arrays.sort(s);
Arrays.stream(s).forEach(System.out::println);
//自定义排序
//1.方式一声明了一个类(只使用了一次)
//MyComparator com = new MyComparator();
//Arrays.sort(s, com);
//Arrays.stream(s).forEach(System.out::println);//输出
//2.方式二(匿名内部类)
/*Arrays.sort(s, new Comparator<Student1>() {
@Override
public int compare(Student1 o1, Student1 o2) {
return o2.getAge()-o1.getAge();
}
});
Arrays.stream(s).forEach(System.out::println);//输出*/
//3.方式三(Lambda表达式)
Arrays.sort(s, (o1,o2)->{return o1.getAge()-o2.getAge();});
Arrays.stream(s).forEach(System.out::println);//输出
}
}
4.枚举类
枚举的底层
最后 班级 cn。HN。day0712。颜色 扩展了 java。郎。Enum < cn。HN。day0712。颜色> {
public static final cn。HN。day0712。颜色 红 ;
public static final cn。HN。day0712。颜色 绿色 ;
public static final cn。HN。day0712。颜色 蓝色 ;
private static final cn。HN。day0712。颜色 [] ENUM $ VALUES ;
static {};
私人 cn。HN。day0712。颜色(java的。郎。字符串,INT);
public static cn。HN。day0712。Color [] values();
public static cn。HN。day0712。颜色 的valueOf(java的。郎。字符串);
}
枚举的应用
import java.util.Scanner;
//枚举类:可以有访问修饰符,可以有抽象方法
enum Color{//三色光类(红绿蓝)
RED(1,"红色") {
@Override
public void cxff() {
System.out.println("red-cxff");
}
},GREEN(2,"绿色") {
@Override
public void cxff() {
System.out.println("green-cxff");
}
},BLUE(3,"蓝色") {
@Override
public void cxff() {
System.out.println("blue-cxff");
}
};//对象(已赋值)
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;
}
@Override
public String toString() {
return this.no+"\t"+this.name;
}
public void show () {
System.out.println("show");
}
//抽象方法
public abstract void cxff();
}
public class TestEnum {
public static void main(String[] args) {
/** 注意:1.底层是一个类,隐式的继承了java.lang.Enum类;
* 2.构造都是 private(所以不能创建对象)
* 3.普通的枚举类都是final(不能扩展子类)
* 4.枚举类的所有对象 必须在枚举类的第一行代码处显示列举出来。而且都是public static final的
*/
System.out.println(Color.RED);//RED
//遍历了所有的枚举对象-------------------
for (Color cr:Color.values()) {
System.out.print(cr.name());
System.out.println("\t"+cr.ordinal());
}
//属性-------------------------------
Color.RED.setNo(11);
Color.RED.setName("红色");
System.out.println(Color.RED.getNo()+"\t"+Color.RED.getName());//11 红色
//switch-----------------------------
Scanner sc = new Scanner(System.in);
System.out.println("--请输入颜色:");
String s = sc.next();
Color color= Color.valueOf(s);
switch (color) {
case RED:
System.out.println("红色的操作!");
break;
case GREEN:
System.out.println("绿色的操作!");
break;
case BLUE:
System.out.println("蓝色的操作!");
break;
}
//构造已赋值-----------------------------
System.out.println(Color.RED);//展示对象名称会调tostring方法
System.out.println(Color.GREEN);
System.out.println(Color.BLUE);
//调用普通方法---------------------------
Color.RED.show();
//调用抽象方法---------------------------
Color.RED.cxff();//red-cxff
Color.GREEN.cxff();//green-cxff
Color.BLUE.cxff();//blue-cxff
}
}