java泛型,枚举

泛型:

参数化数据类型

作用于
类,方法,构造器,接口

泛型类:

在声明类的后面加上类型参数

好处语法

类名<类型参数>
类型参数可以是一个也可以是多个,多个用逗号分隔

用一个大写字母表示,一般用 T-type E—element K—key V—value

原生类型:

类型后没有 指定具体的类型参数,这样的类型

叫 原生类型。

泛型的通配符

?是无界通配符,可以匹配任意的引用类型

? extends 上限类型 及其上限类型的子类型

super 可以匹配下限类和下限类的父类

注意

类型参数可以指定上限(上界),

1.但是只能指定上界

2.还可以指定多个上限

3.上限可以是类也可以是接口

4.上限既有类又有接口,要先继承类,后实现接口;类在前,接口在后

类型参数和通配符的区别

1.类型参数 只能指定上限,通配符可以指定上限和下限

2.类型参数可以指定多个上限,通配符只能指定一个

3.类型参数可以作为一个类型,通配符不能表示为一种类型

问题,String是Object的子类,那么Point 是否是Point的子类型

答:不是,参数化类型不能继承

//用通配符解决

    public void show(Point<String> ps,Point<? extends Object> po){

        po  = ps;

    }

1

2

3

4

5

问题:会生成几个泛型类

一个。泛型只是起到在编译时期进行类型检查的作用,并不会生成多个字节码文件

//验证

Point3<Integer> p1 = new Point3();

        System.out.println(p1.getClass());

        Point3<String> p2 = new Point3<>();

        System.out.println(p2.getClass());

//运行结果:

class day21.Point3

class day21.Point3

泛型构造

package day21;

class Point4<T>{

    private T x;

    private T y;

    //泛型构造器

    <E>Point4(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 Ex4 {

    public static void main(String[] args) {

        //类型推断:根据串的参数的类型确定E是String

        Point4<Integer> p4 = new Point4<Integer>("Hello");

        Point4<Integer> p6 = new Point4<>("hello");

        //显示指定构造器是String类型,此时不能用菱形语法

        Point4<Integer> p5 = new <String>Point4<Integer>("Hello");

    }

}泛型方法

package day21;

//普通类

class Point5{

    //泛型方法

    public <T> void f(T t){

        System.out.println(t);

    }

    //<一>

    //public <T extends Number> T ff (T t){

    //<二>

    public <T extends Number> T ff (T t){

        //自动推断

        f("hello");

        //如果显示指定的化,要用对象去调用:this.<String>f("abc");this.<String>f("abc");都是指定了对象

        this.<String>f("abc");

        return t;

    }

}

public class Ex5 {

    public static void main(String[] args) {

        Point5 p5 = new Point5();

        //类型推断:根据参数的类型推断

        p5.f("Hello");

        p5.f(11);

        //<一>

        //显示指定类型参数

        //p5.<String>f("abc");

        //<二>

        p5.<Double>f(11.0);

    }

}

类型擦除

1.参数化类型擦除后为原生类型

point -> point

2.类型参数:使用上界替换

(1)无界类型参数

Point ——> Object

会用Object替换

(2)指定了一个上限的,用此上限类型来替换

Point ——> Base

(3)指定了多个上限的,用第一个上限替换

Point

重写方法

package day21;

interface IA1{

}

interface IB1{

}

class Base1 {

    public void f(Point6<String> p) throws Exception {}

}

class Sub1 extends Base1 {

    //重写了

    @Override

    public void f(Point6<String> p)  throws Exception{

        // TODO Auto-generated method stub

        super.f(p);

    }

}

class Point6<T>{

    private T 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 Ex6 {

    public void f(Point6<String> p){}//Point6

    public <T> void f(T p){};//Object

    public <T extends Base1> void f(T p){} //Base1

    public <T extends IA1 & IB1> void f(T p){} //IA1

    public static void main(String[] args) {

    }

}

父类参数擦除后和子类相同

异常范围不能比父类大

泛型接口

package day21;

//泛型接口

interface Info <T>{

    void af(T t);

}

//实现类一:实现接口的时候就指定好用什么类型来替换

class InfoImpl1 implements Info<String>{

    @Override

    public void af(String t) {

        // TODO Auto-generated method stub

    }

}

//实现类二:确定不了类型,等应用再定义:InfoImpl2<String>  info = new InfoImpl2<String> ();

class InfoImpl2<T> implements Info<T>{

    @Override

    public void af(T t) {

        // TODO Auto-generated method stub

    }

}

public class Ex7 {

    public static void main(String[] args) {

        InfoImpl2<String>  info = new InfoImpl2<String> ();

    }

}

比较器 TestCompare

自然排序:按照 Comparable接口的方法CompareTo排序

问题:不想按照现有排序方法进行排序,应该怎么解决

实现Comparator 函数式接口

Comparator Exercise4 和 Comparable的区别 Exercise3

1.Comparable是默认的自然排序方式,Comparator 是我们指定的一种排序方式

2.Comparable的比较代码写在要比较对象的类型的内部,Comparator写在比较类型代码的外部

3.Comparable只能指定一种 默认排序方式,Comparator可以定义多种排序方式

枚举

底层就是class类

已经继承了一个类Enum,不能再继承其他的类

对于一个非抽象的枚举类型,默认是final

构造器是private的

不能创建对象,在枚举代码的第一行处

所有的枚举对象都是 public static final的

当枚举的类中定义了抽象方法,那么每个对象的匿名内部类方式都必须实现这个抽象方法,并且这个枚举类为abstract的

语法:

enum Color{

    枚举成员;

    方法();

    构造();

}

1

2

3

4

5

实例代码

package day21;

import java.util.Scanner;

interface InfoNew{

    void af();//抽象方法

}

//可以实现接口

enum Color implements InfoNew{

    //在这里调用构造器

    RED(1,"红色"){

        @Override

        public void af() {

            System.out.println("红色的实现接口");

        }

        @Override

        void f() {

            System.out.println("红色的实现抽象类");

        }

    },GREEN(2,"绿色"){

        @Override

        public void af() {

            System.out.println("绿色的实现接口");

        }

        @Override

        void f() {

            System.out.println("绿色的实现抽象类");

        }

    }, BLUE(3,"蓝色"){

        @Override

        public void af() {

            System.out.println("蓝色的实现接口");

        }

        @Override

        void f() {

            System.out.println("绿色的实现抽象类");         

        }   

    };

    //成员变量

    private int no;

    private String name;

    //构造器  是private的,在这里写没必要

    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 show(){

        System.out.println("show");

    }

    //重写

    @Override

    public String toString() {

        return no + name;

    }

    //定义抽象方法

    abstract void f();

}

public class Ex8 {

    public static void main(String[] args) {

        //重写了Stringto

        System.out.println(Color.RED);

        //定义了构造器

        System.out.println(Color.RED.getName() +","+ Color.RED.getNo());

        System.out.println(Color.BLUE.getName() +","+ Color.BLUE.getNo());

        System.out.println(Color.GREEN.getName() +","+ Color.GREEN.getNo());

        //定义成员变量

/*      Color.RED.no = 11;

        Color.RED.name = "红色";

        System.out.println(Color.RED.name);

        System.out.println(Color.RED.no);

        */

        //私有成员变量

        Color.RED.setNo(22);

        Color.RED.setName("红色");

        System.out.println(Color.RED.getName() +"," +Color.RED.getNo());

        //每一个枚举成员都可以调用自定义方法

        Color.BLUE.show();

        //-----------------------------------

/*      System.out.println(Color.RED);

        System.out.println(Color.GREEN);

        System.out.println(Color.BLUE);

        //遍历

        for (Color c : Color.values()){

            System.out.println(c.name());

            //获得枚举类型的编号

            System.out.println(c.ordinal());

        }

        //-----------Switch------------------

        Scanner input = new Scanner(System.in);

        System.out.println("输入颜色");

        String str = input.next();

        //字符串转换为枚举Color类型

        Color c = Color.valueOf(str);

        switch (c){

        case RED:

            System.out.println("是红色");

            break;

        case GREEN:

            System.out.println("是绿色");

            break;

        case BLUE:

            System.out.println("是蓝色");

            break;

        }*/

    }

}

评论

暂无评论