泛型，枚举

JAVA（泛型，枚举）

泛型：

使用 Java 泛型的概念，我们可以写一个泛型方法来对一个对象数组排序。然后，调用该泛型方法来对整型数组、浮点数数组、字符串数组等进行排序

泛型的修饰：

1.泛型类

2.泛型方法

3.泛型接口

泛型在继承：

1.父类是泛型，子类都可以

2.泛型的声明只能在当前类名后，或者方法中间，且声明的泛型是自己的

3.子类继承父类时，子类泛型和父类泛型都写出来下，父跟子

4.在继承时，没有写出任何泛型，当前子类就不是泛型

泛型类：

泛型类的类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。

一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。

因为他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型。

泛型类的定义：

public class Box<T> {
   
  private T t;
 
  public void add(T t) {
    this.t = t;
  }
 
  public T get() {
    return t;
  }
 
  public static void main(String[] args) {
    //Box<Integer> integerBox = new Box();
    //Box<Integer> integerBox = new Box<>();//JDk7之后
    Box<Integer> integerBox = new Box<Integer>();
    Box<String> stringBox = new Box<String>();
 
    integerBox.add(new Integer(10));
    stringBox.add(new String("泛化"));
 
    System.out.printf("整型值为 :%d\n\n", integerBox.get());
    System.out.printf("字符串为 :%s\n", stringBox.get());
  }
}

泛型方法：

方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型，编译器适当地处理每一个方法调用。

public <T> T show(T t){
    return t; 
}

静态方法

静态方法如果是泛型方法，泛型声明必须写

因为静态结构属于类，不属于某个个对象

比较大小：

public class Test1 {
    // 比较三个值并返回最大值
    public static <T extends Comparable<T>> T maximum(T x, T y, T z)
    //需要继承Comparable的方法，否则用不了comparTo()
    {
        T max = x; // 假设x是初始最大值
        if ( y.compareTo( max ) > 0 ){
            max = y; //y 更大
        }
        if ( z.compareTo( max ) > 0 ){
            max = z; // 现在 z 更大           
        }
        return max; // 返回最大对象
    }
    public static void main( String args[] )
    {
        System.out.printf( "%d, %d 和 %d 中最大的数为 %d\n\n",
                3, 4, 5, maximum( 3, 4, 5 ) );

        System.out.printf( "%.1f, %.1f 和 %.1f 中最大的数为 %.1f\n\n",
                6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ) );

        System.out.printf( "%s, %s 和 %s 中最大的数为 %s\n","pear",
                "apple", "orange", maximum( "pear", "apple", "orange" ) );
    }
}

java 中泛型标记符：

E - Element (在集合中使用，因为集合中存放的是元素)
T - Type（Java 类）
K - Key（键）
V - Value（值）
N - Number（数值类型）
？ - 表示不确定的 java 类型

类型通配符

public class GenericTest {
     
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();
        
        name.add("icon");
        age.add(18);
        number.add(314);
 
        getData(name);
        getData(age);
        getData(number);
       
   }
 
   public static void getData(List<?> data) {
      System.out.println("data :" + data.get(0));
   }
}

枚举

Java 枚举是一个特殊的类，一般表示一组常量，比如一年的 4 个季节，一个年的 12 个月份，一个星期的 7 天，方向有东南西北。

enum Color 
{ 
    RED, GREEN, BLUE; 
}

优点

构造器默认私有化
天然是常量类
枚举的比较推荐 ==

案例

enum Color
{
    RED, GREEN, BLUE;
}
public class MyClass {
  public static void main(String[] args) {
    Color myVar = Color.BLUE;

    switch(myVar) {
      case RED:
        System.out.println("红色");
        break;
      case GREEN:
         System.out.println("绿色");
        break;
      case BLUE:
        System.out.println("蓝色");
        break;
    }
  }
}

values(), ordinal() 和 valueOf() 方法

enum 定义的枚举类默认继承了 java.lang.Enum 类，并实现了 java.lang.Serializable 和 java.lang.Comparable 两个接口。

values(), ordinal() 和 valueOf() 方法位于 java.lang.Enum 类中：

values() 返回枚举类中所有的值。
ordinal()方法可以找到每个枚举常量的索引，就像数组索引一样。
valueOf()方法返回指定字符串值的枚举常量。

枚举单一用例

class Singleton{

    private Singleton(){}

    public static Singleton getInstance(){
        return  SingletonHolder.INSTANT.instant;
    }

    private enum SingletonHolder{

        INSTANT;
        private final Singleton instant;

        SingletonHolder(){
            instant = new Singleton();
        }
    }
}
public class MeiJuDanLi {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        
    }

}

线程

线程由进程创建，是进程的一个实体，是具体做事的
一个进程可以有多个线程，线程不独立分配内存，而是共享进程的内存资源
线程可以共享cpu资源

进程更强调内存资源分配，线程更强调计算的资源分配

线程之间相互隔离，安全性好

1.物理cpu内核，每颗cou可以有1个或多个物理内核

通常情况下物理cpu内核数都是固定的

2.逻辑cpu内核，操作系统可以使用逻辑cpu来模拟真是cpu

进程不能调度线程

不同进程间的线程切换，耗费资源大

posted @ 2022-08-01 09:33 一只神秘的猫阅读(39) 评论(0) 收藏举报

刷新页面返回顶部

一只神秘的猫