ディレクトリ

列挙型

一定の利用インタフェースの設定
列挙java.lang.Enumから継承さ種類、クラスの同等の、各部材は、列挙型のインスタンスであり、デフォルトはパブリックと呼ばれ、静的、最終的な変更、直接列挙型の名前を使用
- 列挙の一般的な方法を入力
- コンストラクタ列挙型
- 各列挙型のメンバー内でインターフェイスメソッドを実装することができます（各メンバーが達成しなければなりません）

//枚举类型的定义与使用
package ex17_enum;

interface Constants {
    public static final int Constants_A = 1;  //将常量放在接口中
    public static final int Constants_B = 12;
}

public class ConstantsTest {
    enum Constants2 {
        Constants_1, Constants_2 //将常量放在枚举类型中
    }

    //使用接口定义的常量
    public static void doit(int c) {
        switch (c) {
            case Constants.Constants_A:
                System.out.println("doit() Constants_A");
                break;
            case Constants.Constants_B:
                System.out.println("doit() Constants_B");
                break;
            default:
                System.out.println("others");
        }
    }

    //使用枚举类型定义的常量
    public static void doit2(Constants2 c) {
        switch (c) {
            case Constants_1:
                System.out.println("doit2() Constants_1");
                break;
            case Constants_2:
                System.out.println("doit2() Constants_2");
                break;
        }
    }

    public static void main(String[] args) {
        ConstantsTest.doit(Constants.Constants_A);  //使用接口中定义的常量
        ConstantsTest.doit(3);

        ConstantsTest.doit2(Constants2.Constants_1);  //使用枚举类型中的常量
        ConstantsTest.doit2(Constants2.Constants_2);
//        ConstantsTest.doit2(3);  //会报错，因为doit2()的入口参数为Constants2枚举类型

    }
}

//枚举类型中的常用方法
package ex17_enum;

public class ShowEnum {
    enum Constants2 {
        CONSTANTS_1, CONSTANTS_2, CONSTANTS_3  //将常量放在枚举类型中
    }

    public static void main(String[] args) {
//        Constants2[] x = Constants2.values();

        //.values() 打印出枚举成员变量
        //.ordinal() 获取枚举类型成员的索引位置
        for (int i = 0; i < Constants2.values().length; i++) {
            System.out.println("枚举类型成员变量："
                    + Constants2.values()[i] +
                    "位置索引：" + Constants2.values()[i].ordinal());
        }

        //.compareTo() 比较定义顺序
        //.valueOf() 将普通字符串转化为枚举类型，必须已经定义
        for (int i = 0; i < Constants2.values().length; i++) {
            int result = Constants2.valueOf("CONSTANTS_2").compareTo(Constants2.values()[i]);
            System.out.println("Constants2.CONSTANTS_2与" + Constants2.values()[i] + "比较" + result);
        }
    }
}

//枚举类型中的构造方法
package ex17_enum;

public class EnumIndexTest {
    enum Constants2 {  //将常量放在枚举类型中
        CONSTANTS_1("我是枚举成员1"),  //定义带参数的枚举常量
        CONSTANTS_2("我是枚举成员2"),
        CONSTANTS_3("我是枚举成员3"),
        CONSTANTS_4(4);
        private String description;
        private int i = 1;

        private Constants2() {
        }  //无参数构造方法  private防止用户实例化一个枚举对象

        private Constants2(String description) {  //参数为String的构造方法
            this.description = description;
        }

        private Constants2(int i) {  //参数为int的构造方法
            this.i = i;
        }

        public String getDescription() {  //获取description的值
            return description;
        }

        public int getI() {  //获取i的值
            return i;
        }

    }

    public static void main(String[] args) {
        Constants2[] cs = Constants2.values();  //获取枚举变量数组
        for (int i = 0; i < cs.length; i++) {
            Constants2 c = cs[i];  //枚举变量
            System.out.println(c + "调用getDescription()方法：" + c.description
                    + " 调用getI()方法：" + c.getI());
        }
    }
}

//在枚举对象中实现接口中的方法
package ex17_enum;

interface d {
    String getDescription();  //默认public

    int getI();
}

public enum AnyEnum implements d {
    CONSTANTS_1 {
        public String getDescription() {
            return "我是枚举类型1";
        }

        public int getI() {
            return i;  //i必须是static，否则使用this.i调用对象的i
        }
    },
    CONSTANTS_2 {
        public String getDescription() {
            return "我是枚举类型2";
        }

        public int getI() {
            return i;  //i必须是static，否则使用this.i调用对象的i
        }
    };

    private static int i;

    public static void main(String[] args) {
        AnyEnum[] anyEnums = AnyEnum.values();  //返回枚举类型数组
        for (int i = 0; i < anyEnums.length; i++) {  //每一个枚举对象调用方法
            AnyEnum anyEnum = anyEnums[i];
            System.out.println(anyEnum + "调用getDescription()方法：" + anyEnum.getDescription()
                    + " 调用getI()方法：" + anyEnum.getI());
        }
    }
}

ジェネリック

アップキャストは安全ですが、意気消沈してたときに間違った種類またはこれを実行しない、コンパイラが受け入れることができますが、実行時にClassCastExceptionがあるでしょう。これは、ダウンキャストは、効果的にこの問題を解決するための一般的なメカニズムを使用する場合、問題は通常発生していること、それはコンパイル時の型チェックになりますが表示されます

ジェネリッククラスの定義
ジェネリック医薬品の一般的な使用方法
- 型宣言MultiOverClass <T1、T2>ジェネリッククラスを定義する複数の、MultiOverClass <ブール、フロート> X =新しいMultiOverClass <>（）;
- 配列型は、ジェネリッククラスを定義するプライベートT []の配列を宣言し、
- 回収容器のクラス宣言の要素
  - 地図：HashMapの、TreeMapの
  - セット：HashSetの、TreeSetの
  - リスト：ArrayListを、TreeList
ジェネリック医薬品の高度な使い方
- 一般的なタイプは、デフォルトですべてのサブクラスのオブジェクトクラスは、一般的なオブジェクトをインスタンス化することができ、制限の使用を制限する使用できません。
  - クラスクラス名anyClass任意のインターフェイスまたはクラス<TがanyClass拡張>を
  - ジェネリック型またはクラスは、キーワードが延び使い、anyClassまたはクラス継承このインタフェースを実装する必要があります
- ワイルドカードを使用
  - 主な役割はされて作成されたジェネリッククラスオブジェクトがあるときに、一般的なクラスのオブジェクト型実装を制限するか、インターフェイスを継承またはクラスのサブクラスを
  - ジェネリッククラス名は、<？リストを拡張> A = NULL;ジェネリッククラスオブジェクトは、サブクラスまたはインタフェースのリストを達成するためにターゲットを割り当てることができます
  - 一覧<？>リストは、一般的なクラスオブジェクトのみを取得することができますまたは削除要素は、新しい情報を追加定義されていません（コンパイラが情報を追加するために何を知らないため？）
- ジェネリック医薬品の上方限界
  - superキーワードを使用します
  - <？スーパー一覧> = NULL;リストは、親クラスタイプのインタフェース又は上層を表すオブジェクトを受け入れます
- 定義はまた、継承とジェネリッククラスとインタフェースとして実装することができます
  - 相続におけるジェネリック医薬品の継承を指定しない場合、サブクラスでオブジェクトタイプにデフォルト設定されます

要約：

ジェネリック型パラメータは、クラスタイプすることができ、単純な型にすることはできません
ジェネリック型パラメータは、複数であってもよいです
あなたは、typeキーワードの制限はスーパージェネリックを拡張し使用することができます
あなたは、ジェネリック型を制限するために、ワイルドカードを使用することができます

//泛型的定义
package ex17_enum;

public class OverClass<T> {  //定义泛型类
    private T over;    //定义泛型类成员变量

    public T getOver() {  //设置getXXX()方法
        return over;
    }

    public void setOver(T over) {  //设置setXXX()方法
        this.over = over;
    }


    public static void main(String[] args) {
        //实例化一个Boolean类型的对象
        OverClass<Boolean> over1 = new OverClass<Boolean>();
        over1.setOver(true);          //不需要向上转型
        Boolean b = over1.getOver();  //不需要向下转型
        System.out.println(b);

        //实例化一个Float类型的对象
        OverClass<Float> over2 = new OverClass<Float>();  //Float可以不写
        over2.setOver(12.3F);       //不需要向上转型
        Float f = over2.getOver();  //不需要向下转型
        System.out.println(f);
    }
}

//定义泛型时，声明多个类型，声明数组
package ex17_enum;

public class MultiOverClass<T1, T2> {
    private T1 multiOver;
    private T2[] multiOver2;  //声明数组类型
//    private T2[] multiOver2 = newT[10];  //不能使用泛型建立数组实例，因为不能确定类型，无法分配内存

    public void setMultiOver(T1 multiOver, T2[] multiOver2) {
        this.multiOver = multiOver;
        this.multiOver2 = multiOver2;
    }

    public T1 getMultiOver() {
        return multiOver;
    }

    public T2[] getMultiOver2() {
        return multiOver2;
    }


    public static void main(String[] args) {
        //自动检测类型，不需要向上转型
        MultiOverClass<Boolean, String> multiOverClass = new MultiOverClass<>();
        multiOverClass.setMultiOver(true, new String[]{"成员1", "成员2"});

        //使用getXXX()方法，不需要向下转型
        Boolean b = multiOverClass.getMultiOver();
        String[] str = multiOverClass.getMultiOver2();

        //输出实例multiOverClass
        System.out.println("getMultiOver: " + b);
        for (String s : str) {
            System.out.println("getMultiOver2: " + s);
        }

    }

}

//集合类声明元素类型
package ex17_enum;

import java.util.*;

public class AnyClass {
    public static void main(String[] args) {
        //Map集合(又称为容器):
        //HashMap 添加和删除映射关系效率高 不保证顺序 允许为null
        //TreeMap 其中的映射关系存在一定顺序 效率比HashMap稍差 键不允许为null
        Map<Integer, String> map = new HashMap<>();
        Map<Integer, String> map1 = new TreeMap<>();
        //为容器填充键和键值
        map.put(33333, "A");
        map1.put(33333, "A");
        map.put(11111, "A");
        map1.put(11111, "A");
        map.put(22222, "B");
        map1.put(22222, "B");
        //获取键和键值--使用迭代器 map不保证顺序 map1排序
        Set<Integer> keySet = map.keySet();  //利用Set构建Map集合中的key集合
        Collection<String> valueColl = map.values();  //利用Collection构建Map中的values集合 值有可能相同
//        Set<Integer> keySet = map1.keySet();  //利用Set构建Map集合中的key集合
//        Collection<String> valueColl = map1.values();  //利用Collection构建Map中的values集合 值有可能相同
        Iterator<Integer> keyIterator = keySet.iterator();
        Iterator<String> valueIterator = valueColl.iterator();
        while (keyIterator.hasNext()) {
            System.out.println("key: " + keyIterator.next()
                    + " value: " + valueIterator.next());
        }


        //Set
        //HashSet 不保证顺序
        //TreeSet 有一定顺序 也可以按照指定比较器递增排序
        Set<String> set = new HashSet<>();
        Set<String> set1 = new TreeSet<>();
        set.add("33333");
        set1.add("33333");
        set.add("11111");
        set1.add("11111");
        set.add("22222");
        set1.add("22222");
        Iterator<String> setIterator = set.iterator();
        Iterator<String> setIterator1 = set1.iterator();
        System.out.println("--------HashSet不保证顺序---------");
        while (setIterator.hasNext()) {
            System.out.println(setIterator.next());
        }
        System.out.println("--------TreeSet增序---------");
        while (setIterator1.hasNext()) {
            System.out.println(setIterator1.next());
        }


        //List
        //ArrayList 可以根据索引位置快速访问 缺点是插入删除速度慢
        //LinkedList 随机访问比ArrayList效率低 优点是插入删除效率比ArrayList高
        List<String> stringList = new ArrayList<>();
        List<String> stringList1 = new LinkedList<>();

    }
}

//泛型的高级用法，限制类型，通配符
package ex17_enum;


import java.util.ArrayList;
import java.util.List;

public class debug {
    public static void main(String[] args) {
        List<String> stringList = new ArrayList<>();
        stringList.add("成员1");
        stringList.add("成员2");
        List<String> stringList1 = stringList;  //没有使用通配符 引用赋值 可添加新信息
        System.out.println("-------删除之前的stringList-------------");
        for (String str : stringList) {
            System.out.println(str);
        }
        stringList1.remove(0);
        System.out.println("-------删除之后的stringList-------------");
        for (String str : stringList) {
            System.out.println(str);
        }
        stringList1.add("成员3(stringList1添加的)");
        System.out.println("-------添加成员-------------");
        for (String str : stringList) {
            System.out.println(str);
        }

        System.out.println("----------------------------");
        List<?> stringList2 = stringList;  //使用List<?> 引用赋值 不能添加新信息 只能获取或删除
        System.out.println("获取信息：" + stringList2.get(1));
        System.out.println("删除信息：" + stringList2.remove(1));
//        stringList2.add("不可添加成员");
//        stringList2.set(0,"不可添加成员");  //不能添加新信息
        for (String str : stringList) {
            System.out.println(str);
        }
    }
}

Bingmous

公開された46元の記事・ウォンの賞賛0 ・ビュー1018

プライベートの手紙の懸念

Javaのエントリからマスター第17章列挙型とジェネリックへ

列挙型

ジェネリック

おすすめ