import kafka.utils.ShutdownableThread;

public class Consumer extends ShutdownableThread {

    ...

}

    @Override

    public void doWork() {

        consumer.subscribe(Collections.singletonList(this.topic));

        ConsumerRecords<Integer, String> records = consumer.poll(Duration.ofSeconds(1));

        debug_index++;

        System.out.println("\n[" + debug_index + "] 消费到消息数:" + records.count());

        if (records.count() > 0) {

            for (ConsumerRecord<Integer, String> record : records) {

                LOG.warn("[" + debug_index + "]Received message: (" + record.key() + ", " + record.value() + ") at offset " + record.offset());

                String value = record.value();
                /* 将消息进行下一步处理 */

            }

        }

        System.out.println("[" + debug_index + "] nothing.");

    }

import kafka.utils.ShutdownableThread;

import org.apache.kafka.clients.consumer.ConsumerRecord;

import org.apache.kafka.clients.consumer.ConsumerRecords;

import org.apache.kafka.clients.consumer.KafkaConsumer;

# 原型
public class KafkaConsumer<K, V> implements Consumer<K, V>

# 使用案例

consumer = new KafkaConsumer<>(props);

System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);

System.out.println("包装类：java.　　.Byte");

System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);

System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);

final double PI = 3.1415927;

低  ------------------------------------>  高

byte,short,char—> int —> long—> float —> double 

// Synchronized 锁定的是对象而非函数或代码。 
public synchronized void showDetails(){

.......

}

String name = "James";

boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真

public class Test {

   public static void main(String args[]){

      int [] numbers = {10, 20, 30, 40, 50};

      for(int x : numbers ){

         System.out.print( x );

         System.out.print(",");

      }
   }

}

# 浮点数

Math.abs(x-0.1) < 0.00001

# 是否指向同一对象

s1 == s2

# 判断内容是否相等，要小心s1=null，会报错

s1 != null && s1.equals("hello")
"hello".equals(s1)

Integer x = 5;

x =  x + 10;

public class Test {

    public static void main (String []args)

    {

        System.out.println("90 度的正弦值：" + Math.sin(Math.PI/2));

        System.out.println("0度的余弦值："   + Math.cos(0));

        System.out.println("60度的正切值："  + Math.tan(Math.PI/3));

        System.out.println("1的反正切值： "  + Math.atan(1));

        System.out.println("π/2的角度值：" 　+ Math.toDegrees(Math.PI/2));

        System.out.println(Math.PI);

    }

}

Character ch = new Character('a');

// 初始化方法
dataType[] arrayRefVar = new dataType[arraySize];

dataType[] arrayRefVar = {value0, value1, ..., valuek};

String str[][] = new String[3][4];

for (int n: ns) {

　　...

}

import java.util.Arrays;

public class main

{

    public static void main(String[] args)

    {

        int []arr=new int[10];

        Arrays.fill(arr, 5);

        System.out.println(Arrays.toString(arr));

        int [] nums = {6,1,5,9,3,5,7,2,3,9};

        Arrays.sort(nums);

        System.out.println(Arrays.toString(nums));　　# 排序后，修改了数组本身

        int [] nums1 = {6,1,5,9,3,5,7,2,3,9};

        int [] nums2 = {6,2,5,9,3,5,7,2,3,9};

        int [] nums3 = {6,1,5,9,3,5,7,2,3,9};

        System.out.println(Arrays.equals(nums1, nums2));

        System.out.println(Arrays.equals(nums1, nums3));

        int xb=Arrays.binarySearch(nums, 5);

        System.out.println(xb);

    }

}

import java.util.Date;

public class DateDemo {

   public static void main(String args[]) {

       // 初始化 Date 对象

       Date date = new Date();

       // 使用 toString() 函数显示日期时间

       System.out.println(date.toString());

   }

}

import java.util.regex.*;

class RegexExample1{

   public static void main(String args[]){

      // 参数

      String content = "I am noob " + "from runoob.com.";

      String pattern = ".*runoob.*";

      boolean isMatch = Pattern.matches(pattern, content);　　// <----

      System.out.println("字符串中是否包含了 'runoob' 子字符串? " + isMatch);

   }

}

public class VarargsDemo {

    public static void main(String args[]) {
        // 调用可变参数的方法

        printMax(34, 3, 3, 2, 56.5);

        printMax(new double[]{1, 2, 3});

    }

    public static void printMax( double... numbers) {　　//numbers已经变成了一个数组

        if (numbers.length == 0) {

            System.out.println("No argument passed");

            return;

        }

        double result = numbers[0];

        for (int i = 1; i <  numbers.length; i++){

            if (numbers[i] >  result) {

                result = numbers[i];

            }

        }

        System.out.println("The max value is " + result);

    }

}

public class FinalizationDemo {  

  public static void main(String[] args) {

    Cake c1 = new Cake(1);

    Cake c2 = new Cake(2);

    Cake c3 = new Cake(3);  

    c2 = c3 = null;

    System.gc(); //调用Java垃圾收集器，当垃圾回收器(garbage colector)决定回收某对象时，就会运行该对象的finalize()方法。

  }

}


class Cake extends Object {  　　//finalize()是在java.lang.Object里定义的

  private int id;

  public Cake(int id) {

    this.id = id;

    System.out.println("Cake Object " + id + "is created");

  }  

  protected void finalize() throws java.lang.Throwable {

    super.finalize();

    System.out.println("Cake Object " + id + "is disposed");

  }

}

import java.util.Scanner;

public class Hello {

　　public static void main(String[] args) {

　　　　Scanner scanner = new Scanner(System.in);

　　　　String name = scanner.nextline();　　# 读字符串

　　　　int age = scanner.nextInt();　　     # 读整数

　　}

}

import java.util.Scanner; 

public class ScannerDemo {

    public static void main(String[] args) {
Scanner scan = new Scanner(System.in);

        // 从键盘接收数据

        // next方式接收字符串

        System.out.println("next方式接收：");

        // 判断是否还有输入

        if (scan.hasNext()) {

            String str1 = scan.next();

            System.out.println("输入的数据为：" + str1);

        }

        scan.close();

    }

}

# 直接获得
InputStream input = new FileInputStream("C:/java/hello");

# 间接获得：File --> InputStream

File f = new File("C:/java/hello");

InputStream input = new FileInputStream(f);

OutputStream output = new FileOutputStream("C:/java/hello")

File f = new File("C:/java/hello");

OutputStream output = new FileOutputStream(f);

import java.io.*;

public class FileRead{

   public static void main(String args[])throws IOException{

      File file = new File("Hello1.txt");

      // 创建文件

      file.createNewFile();

      // creates a FileWriter Object

      FileWriter writer = new FileWriter(file); 

      // 向文件写入内容

      writer.write("This\n is\n an\n example\n");

      writer.flush();

      writer.close();

      // 创建 FileReader 对象

      FileReader fr = new FileReader(file);

      char [] a = new char[50];

      fr.read(a); // 读取数组中的内容

      for(char c : a)

          System.out.print(c); // 一个一个打印字符

      fr.close();

   }

}

try {

　　file = new FileInputStream(fileName);

　　x    = (byte) file.read();

} catch (IOException i){

　　i.printStackTrace();

　　return -;


} catch (FileNotFoundException f){

　　f.printStackTrace();

　　return -;

}

int age = 0;

age = -100;

System.out.println(age);  

int age = 0;

age = -100;

if(age < 0)

{

　　Exception e = new Exception();　　// ----> 创建异常对象

　　throw e;　　　　　　　             // ----> 抛出异常

}

System.out.println(age); 

/**

 * fun()可能会抛出两种异常

 */

void fun()throws IOException,SQLException

{

    ...

}  

try {

　　fun();

　　/**

　　 * 调用fun()的时候，就知道该如何做准备来处理异常了

　　 */

} catch (IOException e){

  　...

} catch (SQLException e){

    ...

} finally {
　　...
}

(3) suppressed exception

在这里，RuntimeException不再抛出，因为finally中抛出的exception将其覆盖，也就是＂被屏蔽＂掉了．

public static void main(String[] args) {

　　try {

　　　　process1("");

　　} catch (Exception e) {

　　　　System.out.println("catched");

　　　　throw new RuntimeException(e);

　　} finally {

　　　　System.out.println("finally");

　　　　throw new NullPointerException();

　　}

}

static void process1(String s) {

　　throw new IllegalArgumentException(e);

}

# 其他exception 都继承这个自定义的 BaseException
public class BaseException extends RuntimeException {

　　public BaseException() {
　　　　super();
　　}

　　public BaseException(String message, Throwable cause) {
　　　　super(message, cause);
　　}

　　public BaseException(String message) {
　　　　super(message);
　　}

　　public BaseException(Throwable cause) {
　　　　super(cause);
　　}
}

public class UserNotFoundException extends BaseException {

}

public class LoginFailedException extends BaseException {

}

// 文件名InsufficientFundsException.java

import java.io.*;

//自定义异常类，继承Exception类

public class InsufficientFundsException extends Exception

{

  //此处的amount用来储存当出现异常（取出钱多于余额时）所缺乏的钱

  private double amount;

  public InsufficientFundsException(double amount)

  {

    this.amount = amount;

  } 

  public double getAmount()

  {

    return amount;

  }

}

// 文件名称 CheckingAccount.java

import java.io.*;

//此类模拟银行账户

public class CheckingAccount

{

  //balance为余额，number为卡号

   private double balance;

   private int number;

   public CheckingAccount(int number)

   {

      this.number = number;

   }

  //方法：存钱

   public void deposit(double amount)

   {

      balance += amount;

   }

  //方法：取钱

   public void withdraw(double amount) throws InsufficientFundsException

   {

      if(amount <= balance)

      {

         balance -= amount;

      }

      else

      {

         double needs = amount - balance;

         throw new InsufficientFundsException(needs);　　// --> 02.抛出了自定义异常

      }

   }

  //方法：返回余额

   public double getBalance()

   {

      return balance;

   }

  //方法：返回卡号

   public int getNumber()

   {

      return number;

   }

}

//文件名称 BankDemo.java

public class BankDemo

{

   public static void main(String [] args)

   {

      CheckingAccount c = new CheckingAccount(101);

      System.out.println("Depositing $500...");

      c.deposit(500.00);

      try {

         System.out.println("\nWithdrawing $100...");

         c.withdraw(100.00);

         System.out.println("\nWithdrawing $600...");

         c.withdraw(600.00);　　　　　　　　　　　　　　　　// --> 01.透支，需要抛出异常
          /**
           * 上述函数可能会抛出异常，那么下面就做好处理的准备。
           * catch是了解withdraw会抛出怎样异常的！
           */

      }catch(InsufficientFundsException e) {　　  　　　　// --> 03. 这里捕获自定义异常

         System.out.println("Sorry, but you are short $" + e.getAmount());

         e.printStackTrace();

      }

    }

}

// package语句
// import语句
// 类定义

public class Puppy{

   int puppyAge;

   static int cls_var = 10

   public Puppy(String name){

      System.out.println("小狗的名字是 : " + name );

   }

   public void setAge( int age ){

       puppyAge = age;

   }

   public int getAge( ){

       System.out.println("小狗的年龄为 : " + puppyAge );

       return puppyAge;

   }

   public static void main(String []args){

      Puppy myPuppy = new Puppy( "tommy" );

      myPuppy.setAge( 2 );

      myPuppy.getAge( );　　

      System.out.println("变量值 : " + myPuppy.puppyAge );

   }

}

/* 文件名: EncapTest.java */

public class EncapTest{

   private String name;

   private String idNum;

   private int age;

   public int getAge(){

      return age;

   }

   public String getName(){

      return name;

   }

   public String getIdNum(){

      return idNum;

   }

   public void setAge( int newAge){

      age = newAge;

   }

   public void setName(String newName){

      name = newName;

   }

   public void setIdNum( String newId){

      idNum = newId;

   }

}

/* F文件名 : RunEncap.java */

public class RunEncap{

   public static void main(String args[]){

      EncapTest encap = new EncapTest();

      encap.setName("James");

      encap.setAge(20);

      encap.setIdNum("12343ms");

      System.out.print("Name : " + encap.getName() + Age : " + encap.getAge());

    }

}

class 子类 extends 父类 {
　　...

}

public interface A {

    public void eat();

    public void sleep();

}

public interface B {

    public void show();

}

public class C implements A,B {
　　...

}

class Animal {

　　void eat() {

　　　　System.out.println("animal : eat");

　　}

}

class Dog extends Animal {

　　void eat() {

　　　　System.out.println("dog : eat");

　　}

　　void eatTest() {

　　　　this.eat();   　　// this 调用自己的方法

　　　　super.eat();  　　// super 调用父类方法

　　}

}

public class Test {

  public static void main(String[] args) {

    Animal a = new Animal();

    a.eat();

    Dog d = new Dog();

    d.eatTest();

  }

}

final class 类名 {//类体}

class SuperClass {

　　private int n;

　　SuperClass(){

　　　　System.out.println("SuperClass()");

　　}

　　SuperClass(int n) {

　　　　System.out.println("SuperClass(int n)");

　　　　this.n = n;

　　}

}

class SubClass extends SuperClass{

　　private int n;

　　SubClass(){

   　　super(300);　　// 给自己的父类传参

　　　　System.out.println("SubClass");

　　}  

　　public SubClass(int n){

　　　　System.out.println("SubClass(int n):"+n);

　　　　this.n = n;

　　}

}

public class TestSuperSub{

　　public static void main (String args[]){

　　　　SubClass sc  = new SubClass();

　　　　SubClass sc2 = new SubClass(200);

　　}

}

Student n = null;

System.out.println(n instanceof Student); 　　//false

Person  p = new Person("Xiao Ming");

Student s = new Student("Xiao Hong");

Person ps = s;

// 明眼人明白，这里的ps的实际类型，其实原本还是Student．

Student s2 = (Student) ps;

s2.run();

if (p instanceof Student) {

　　Student s2 = (Student) p;

　　s2.run();

}

public class TestDog{

   public static void main(String args[]){

      Animal a = new Animal(); 　　  // Animal 对象

      Animal b = new Dog();         // Dog 对象

      a.move();　　　　　　　　　　　　 // 执行 Animal 类的方法

      b.move();　　　　　　　　　　　　 // 执行 Dog 类的方法

      b.bark();

   }

}

// 文件名: Sports.java

public interface Sports

{

   public void setHomeTeam(String name);

   public void setVisitingTeam(String name);

}

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

// 文件名: Football.java

public interface Football extends Sports

{

   public void homeTeamScored(int points);

   public void visitingTeamScored(int points);

   public void endOfQuarter(int quarter);

}

// 文件名: Hockey.java

public interface Hockey extends Sports　　　　// Hockey接口自己声明了四个方法，从Sports接口继承了两个方法

{

   public void homeGoalScored();

   public void visitingGoalScored();

   public void endOfPeriod(int period);

   public void overtimePeriod(int ot);

}

import java.util.List;

import java.util.RandomAccess;

public class SourceLearning

{

    public void iteratorElements(List<String> list)　　// 这里的list可能只是override

    {

        if (list instanceof RandomAccess)

        {

            for (int i = 0, size = list.size(); i < size; i++)

            {

                String element = list.get(i);

            }

        }

        else

        {

            for (String element : list)

            {
　　　　　　　    // ... ...

            }

        }

    }

}

public class ArrayList<E> extends AbstractList<E>

                          implements List<E>, RandomAccess, Cloneable, java.io.Serializable

{

　　//...

}

// 而LinkedList就没有实现该标记接口

public class LinkedList<E> extends AbstractSequentialList<E>

                           implements List<E>, Deque<E>, Cloneable, java.io.Serializable

{

　　//...

}

public interface Cloneable {

    ... ...

} 

/* 文件名: Animal.java */

package animals;

interface Animal {public void eat();

   public void travel();

}

package animals;

/* 文件名 : MammalInt.java */

public class MammalInt implements Animal{

   public void eat(){

      System.out.println("Mammal eats");

   }

   public void travel(){

      System.out.println("Mammal travels");

   } 

   public int noOfLegs(){

      return 0;

   }

   public static void main(String args[]){

      MammalInt m = new MammalInt();

      m.eat();

      m.travel();

   }

}

$ java animals/MammalInt

Mammal eats

Mammal travel

package payroll;

public class Boss

{

   public void payEmployee(Employee e)　　 //payroll 包已经包含了 Employee 类，不用实用功能全名：payroll.Employee

   {

      e.mailCheck();

   }

}

....\com\runoob\test\Runoob.java

// 文件名: Runoob.java

package com.runoob.test;

public class Runoob {

}

class Google {

}

$javac -d . Runoob.java

.\com\runoob\test\Runoob.class

.\com\runoob\test\Google.class

<path-one>\sources\com\runoob\test\Runoob.java

<path-two>\classes\com\runoob\test\Google.class
|-- class path ---|--- package ---|

import java.util.Vector;

import java.util.Enumeration;

public class EnumerationTester {

   public static void main(String args[]) {

      Enumeration<String> days;

      Vector<String> dayNames = new Vector<String>();

      dayNames.add("Sunday");

      dayNames.add("Monday");

      dayNames.add("Tuesday");

      dayNames.add("Wednesday");

      dayNames.add("Thursday");

      dayNames.add("Friday");

      dayNames.add("Saturday");

      days = dayNames.elements();

      while (days.hasMoreElements()){

         System.out.println(days.nextElement());

      }

   }

}

import java.util.BitSet;

public class BitSetDemo {

  public static void main(String args[]) {

     BitSet bits1 = new BitSet(16);

     BitSet bits2 = new BitSet(16);

     // set some bits

     for(int i=0; i<16; i++) {

        if((i%2) == 0) bits1.set(i);

        if((i%5) != 0) bits2.set(i);

     }

     System.out.println("Initial pattern in bits1: ");

     System.out.println(bits1);

     System.out.println("\nInitial pattern in bits2: ");

     System.out.println(bits2);

     // AND bits

     bits2.and(bits1);

     System.out.println("\nbits2 AND bits1: ");

     System.out.println(bits2);

     // OR bits

     bits2.or(bits1);

     System.out.println("\nbits2 OR bits1: ");

     System.out.println(bits2);

     // XOR bits

     bits2.xor(bits1);

     System.out.println("\nbits2 XOR bits1: ");

     System.out.println(bits2);

  }

}

# 1

get(int index);

# 2

List<String> list = ...

for (Iterator<String> it = list.iterator(); it.hasNext(); )

{

　　String s = it.next();

}

# 3. 除了数组外，实现了Iterable接口的都可以使用foreach
for (String s: list) {
　　...
}

List<Integer> list = new ArrayList<>();

list.add(1);

list.add(2);

list.add(3);

Integer[] array = list.toArray(new Integer[3]);

Integer[] array = {1,2,3};

List<Integer> arrayList = new ArrayList<>(Arrays.asList(array));

import java.util.*;

public class CollectionsDemo {

   public static void main(String[] args) {

      Map m1 = new HashMap();

      m1.put("Zara",   "8");

      m1.put("Mahnaz", "31");

      m1.put("Ayan",   "12");

      m1.put("Daisy",  "14");

      System.out.println();

      System.out.println(" Map Elements");

      System.out.print("\t" + m1);

   }

}

Map<String, Integer> map = ...

for ( Map.Entry<String, Integer> entry : map.entrySet() ) {

　　String key    = entry.getKey();

　　Integer value = entry.getValue();

}

• SortedMap

自定义排序算法： 　　

Map<String, Integer> map = new Tree<>(new Comparator<String>() {

　　public int compare(String o1, Stringo2) {

　　　　return -o1.compareTo(o2);

　　}

});

import java.util.*;

public class StackDemo {

    static void showpush(Stack<Integer> st, int a) {

        st.push(new Integer(a));

        System.out.println("push(" + a + ")");

        System.out.println("stack: " + st);

    }

    static void showpop(Stack<Integer> st) {

        System.out.print("pop -> ");

        Integer a = (Integer) st.pop();

        System.out.println(a);

        System.out.println("stack: " + st);

    }

    public static void main(String args[]) {

        Stack<Integer> st = new Stack<Integer>();

        System.out.println("stack: " + st);

        showpush(st, 42);　　// push

        showpush(st, 66);

        showpush(st, 99);

        showpop(st);　　　　  // pop

        showpop(st);

        showpop(st);

        try {

            showpop(st);

        } catch (EmptyStackException e) {

            System.out.println("empty stack");

        }

    }

}

boolean addAll(Collection<? super T> c, T... elements)

List<T> emptyList()

Map<K,V> emptyMap()

Set<T> emptySet()

Set<T> singleTon(T o)

List<T> singletonList(T o)

Map<K, V> singletonMap(K key, V value)

void sort(List<T> list)

void sort(List<T> list, Comparator<? super T> c)

void shuffle(List<?> list)

List<T> unmodifiableList(List<? extends T> list)

Set<T> unmodifiableSet(Set<? extends T> set)

Map<K, V> unmodifiableMap(Map<? extends K, ? extends V> m)

List<T> synchronizedList(List<T> list)

Set<T> synchronizedSet(Set<T> s)

Map<T> synchronizedMap(Map<K,V> m)

class Class {

}

# sol 1, 直接获得
Class cls = String.class;

# sol 2, 间接获得

String s = "Hello";

Class cls = s.getClass();

# sol 3

Class cls = Class.forName("java.lang.String")

Integer n  = new Integer(123);

Class cls  = n.getClass();

Field[] fs = cls.getFields();

for (Field f : fs) {

　　f.getName();　　// field name

　　f.getType();　　 // field type

　　f.getModifiers();  // modifiers

}

Field f = cls.getDeclaredField("value");
f.set(n, 456);　　// 相当于 n.value = 456

Integer n = new Integer(123);

Class cls = n.getClass();

Method m  = cls.getMethod("compareTo", Integer.class);

int r = (Integer) m.invoke(n, 456);

public class GenericMethodTest

{

   // 泛型方法 printArray

   public static <E> void printArray( E[] inputArray )

   {

      // 输出数组元素

         for ( E element : inputArray ){

            System.out.printf( "%s ", element );

         }

         System.out.println();

    }

    public static void main( String args[] )

    {

        // 创建不同类型数组： Integer, Double 和 Character

        Integer[]   intArray    = { 1, 2, 3, 4, 5 };

        Double[]    doubleArray = { 1.1, 2.2, 3.3, 4.4 };

        Character[] charArray   = { 'H', 'E', 'L', 'L', 'O' };

        System.out.println( "整型数组元素为:" );
printArray( intArray  );   // 传递一个整型数组

        System.out.println( "\n双精度型数组元素为:" );
printArray( doubleArray ); // 传递一个双精度型数组

        System.out.println( "\n字符型数组元素为:" );
printArray( charArray );   // 传递一个字符型数组

    }

}

public class GenericMethod {

    public <K,V> void f(K k,V v) {

        System.out.println(k.getClass().getSimpleName());

        System.out.println(v.getClass().getSimpleName());

    }

    public static void main(String[] args) {

        GenericMethod gm = new GenericMethod();

        gm.f(new Integer(0), new String("generic"));

    }

}

Integer

String

public class MaximumTest

{

   // 比较三个值并返回最大值

   public static <> T maximum(T x, T y, T z)

   {

      T max = x;

      if ( y.compareTo( max ) > 0 ){

         max = y;

      }

      if ( z.compareTo( max ) > 0 ){

         max = 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" ) );

   }

}

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<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 class ErasedTypeEquivalence {

    public static void main(String[] args) {

        Class c1 = new ArrayList<String>().getClass();

        Class c2 = new ArrayList<Integer>().getClass();

        System.out.println(c1 == c2);

    }

} 

class HasF {

    public void f() {　// 这里虽然定义了f()这个函数，但调用处搞不清楚．

        System.out.println("HasF.f()");

    }

}

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

public class Manipulator<T> {　　// <----　这里需要之后改进 -_-b

    private T obj;

    public Manipulator(T obj) {

        this.obj = obj;

    }

    public void manipulate() {

        obj.f(); //无法编译 找不到符号 f()，编译器不清楚有没有，没有根据．

    }

    public static void main(String[] args) {

        HasF hasF  = new HasF();

        Manipulator<HasF> manipulator = new Manipulator<>(hasF);

        manipulator.manipulate();

    }

}

class Manipulator2<T extends HasF> {

    private T obj;

    public Manipulator2(T x) { obj = x; }

    public void manipulate() { obj.f(); }

}

public class Erased<T> {

    private final int SIZE = 100;

    public static void f(Object arg) {

    　　if(arg instanceof T) {}          // Error

   　　 T var     = new T();             // Error

   　　 T[] array = new T[SIZE];         // Error

  　　  T[] array = (T)new Object[SIZE]; // Unchecked warning

    }

}

interface FactoryI<T> {

    T create();

}

class Foo2<T> {

    private T x;

    public <F extends FactoryI<T>> Foo2(F factory) {

    　　x = factory.create();　　//　通过factory实现了new的功能

    }

    // ...

}

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

　　class IntegerFactory implements FactoryI<Integer> {

    　　public Integer create() {

    　　　　return new Integer(0);

    　　}

　　}

class Widget {

    public static class Factory implements FactoryI<Widget> {

        public Widget create() {

            return new Widget();

        }

    }

}

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

public class FactoryConstraint {

    public static void main(String[] args) {

        new Foo2<Integer>(new IntegerFactory());

        new Foo2<Widget>(new Widget.Factory());

    }

}

abstract class GenericWithCreate<T> {

    final T element;

    GenericWithCreate() { element = create(); }

    abstract T create();

}

class X {}

class Creator extends GenericWithCreate<X> {

    X create() { return new X(); }

    void f() {

    　　System.out.println(element.getClass().getSimpleName());

    }

}

public class CreatorGeneric {

    public static void main(String[] args) {

        Creator c = new Creator();

        c.f();

    }

}

public class IntPair extends Pair<Integer> {

}

IntPair ip = new IntPair(1, 2);

Class<IntPair> clazz = IntPair.class;

Type t = clazz.getGenericSuperclass();

// Type的实际类型就是如下所示的 ParameterizedType

if (t instanceof ParameterizedType) {

　　ParameterizedType pt = (ParameterizedType) t;

　　Type[] types = pt.getActualTypeArguments();

　　Type firstType = types[0];

　　Class<?> typeClass = (Class<?>) firstType;

　　System.out.println(typeClass);　　// Integer

}

Fruit[] fruit = new Apple[10];

fruit[0] = new Apple(); // OK

fruit[1] = new Jonathan(); // OK

// Compile Error: incompatible types:

ArrayList<Fruit> flist = new ArrayList<Apple>();　　// 引来问题 --->

List<? extends Fruit> flist = new ArrayList<Apple>();　　// 解决问题 <---

public class Holder<T> {

    private T value;

    public Holder() {}

    public Holder(T val) { value = val; }

    public void set(T val) { value = val; }

    public T get() { return value; }

    public boolean equals(Object obj) {

    　　return value.equals(obj);

    }

    public static void main(String[] args) {

        Holder<Apple> Apple = new Holder<Apple>(new Apple());

        Apple d = Apple.get();

        Apple.set(d);

        // Holder<Fruit> Fruit = Apple;        // Cannot upcast

        Holder<? extends Fruit> fruit = Apple; // OK

        Fruit p = fruit.get();

        d = (Apple)fruit.get(); // Returns ‘Object’

        try {

            Orange c = (Orange)fruit.get(); // No warning
        } catch(Exception e) { 
　　　　　　　System.out.println(e); 
        }

        // fruit 的类型是 Holder<? extends Fruit>，所以set()方法不会接受任何对象的添加。

        // fruit.set(new Apple()); // Cannot call set()

        // fruit.set(new Fruit()); // Cannot call set()

        System.out.println(fruit.equals(d)); // OK

    }

} /* Output: (Sample)

java.lang.ClassCastException: Apple cannot be cast to Orange

public class SuperTypeWildcards {

    static void writeTo(List<? super Apple> apples) {

        apples.add(new Apple());

        apples.add(new Jonathan());

        // apples.add(new Fruit()); // Error，Fruit是Apple的父类！

    }

}

public class Collections {

　　public static <T> void copy(List<? super T> dest, List<? extends T> src)

　　{

　　　　for (int i=0; i<src.size(); i++) {

　　　　　　dest.set(i, src.get(i)); 
　　　　}

　　}

}

import java.io.*;

public class SerializeDemo

{

   public static void main(String [] args)

   {

      Employee e = new Employee();

      e.name     = "Reyan Ali";

      e.address  = "Phokka Kuan, Ambehta Peer";

      e.SSN      = 11122333;

      e.number   = 101;

      try {

         File OutputStream fileOut = new FileOutputStream("/tmp/employee.ser"); # 序列化文件约定这么起名字

         Object OutputStream out   = new ObjectOutputStream(fileOut);

         out.writeObject(e);

         out.close();
fileOut.close();

         System.out.printf("Serialized data is saved in /tmp/employee.ser");

      } catch(IOException i) {

          i.printStackTrace();

      }

   }

}

import java.io.*;

public class DeserializeDemo

{

   public static void main(String [] args)

   {

      Employee e = null;

      try {

         File InputStream fileIn = new FileInputStream("/tmp/employee.ser");

         Object InputStream in   = new ObjectInputStream(fileIn);

         e = (Employee) in.readObject();

         in.close();
fileIn.close();

      } catch(IOException i) {

         i.printStackTrace();

         return;

      } catch (ClassNotFoundException c) {

         System.out.println("Employee class not found");

         c.printStackTrace();

         return;

      }

      System.out.println("Deserialized Employee...");

      System.out.println("Name: " + e.name);

      System.out.println("Address: " + e.address);

      System.out.println("SSN: " + e.SSN);

      System.out.println("Number: " + e.number);

    }

}

// 文件名 GreetingClient.java

import java.net.*;

import java.io.*;

public class GreetingClient

{

   public static void main(String [] args)

   {

      String serverName = args[0];

      int    port       = Integer.parseInt(args[1]);

      try

      {

         System.out.println("连接到主机：" + serverName + " ，端口号：" + port);
         Socket client = new Socket(serverName, port);　　             // Create socket

         System.out.println("远程主机地址：" + client.getRemoteSocketAddress());

         OutputStream outToServer = client.getOutputStream();　　      // Create stream channel at local

         DataOutputStream out = new DataOutputStream(outToServer);　　 // Create data   channel at local

         out.writeUTF("Hello from " + client.getLocalSocketAddress()); // <---- 发数据

         InputStream inFromServer = client.getInputStream();           // <---- Create stream channel at local 等回应

         DataInputStream in = new DataInputStream(inFromServer);

         System.out.println("服务器响应： " + in.readUTF());

         client.close();

      }catch(IOException e)

      {

         e.printStackTrace();

      }

   }

}

// 文件名 GreetingServer.java

import java.net.*;

import java.io.*;

public class GreetingServer extends Thread

{

   private ServerSocket serverSocket;

   public GreetingServer(int port) throws IOException

   {

      serverSocket = new ServerSocket(port);

      serverSocket.setSoTimeout(10000);

   }

   public void run()

   {

      while(true)

      {

         try

         {

            System.out.println("等待远程连接，端口号为：" + serverSocket.getLocalPort() + "...");

            Socket server = serverSocket.accept();

            System.out.println("远程主机地址：" + server.getRemoteSocketAddress());

            DataInputStream in = new DataInputStream(server.getInputStream());　　// ----> 先stream 后data

            System.out.println(in.readUTF());

            DataOutputStream out = new DataOutputStream(server.getOutputStream());　　// ----> 准备应答，先stream 后data

            out.writeUTF("谢谢连接我：" + server.getLocalSocketAddress() + "\nGoodbye!");
server.close();

         }catch(SocketTimeoutException s)

         {

            System.out.println("Socket timed out!");

            break;

         }catch(IOException e)

         {

            e.printStackTrace();

            break;

         }

      }

   }

   public static void main(String [] args)

   {

      int port = Integer.parseInt(args[0]);

      try

      {

         Thread t = new GreetingServer(port);　　// Create thread to listen

         t.run();

      }catch(IOException e)

      {

         e.printStackTrace();

      }

   }

}

class RunnableDemo implements Runnable {

   private Thread t;

   private String threadName;

   RunnableDemo( String name) {

      threadName = name;

      System.out.println("Creating " +  threadName );

   }

   public void run() {　　  // 运行状态

      System.out.println("Running " +  threadName );

      try {

         for(int i = 4; i > 0; i--) {

            System.out.println("Thread: " + threadName + ", " + i);

            // 让线程睡眠一会

            Thread.sleep(50);

         }

      }catch (InterruptedException e) {

         System.out.println("Thread " +  threadName + " interrupted.");

      }

      System.out.println("Thread " +  threadName + " exiting.");

   }

   public void start() {　　// 就绪状态

      System.out.println("Starting " +  threadName );

      if (t == null) {

         t = new Thread (this, threadName);

         t.start ();

      }

   }
}

public class TestThread {

   public static void main(String args[]) {

      RunnableDemo R1 = new RunnableDemo( "Thread-1");

      R1.start();　　// ----> 进入就绪状态

      RunnableDemo R2 = new RunnableDemo( "Thread-2");

      R2.start();

   }

}

class ThreadDemo extends Thread {
private Thread t;

   private String threadName;

   ThreadDemo( String name) {

      threadName = name;

      System.out.println("Creating " +  threadName );

   }

   public void run() { 　　// ----> 重写该类的run()方法，线程的执行体

    　　... ...

   }

   public void start() {

      ... ...
}

public class TestThread {

   public static void main(String args[]) {

      ThreadDemo T1 = new ThreadDemo( "Thread-1");

      T1.start();

      ThreadDemo T2 = new ThreadDemo( "Thread-2");

      T2.start();

   }

}

public class CallableAndFuture {

    public static void main(String[] args) {


        Callable<Integer> callable = new Callable<Integer>() {
public Integer call() throws Exception {　　　　　　　　// ----> call作为线程执行体，且可以有返回值

                return new Random().nextInt(100);

            }
};

        /*
         * 1. callable是个类的实例，里面定义了线程执行体函数call()。
         * 2. future这个类来代表callable所代表线程的返回值。
         */

        FutureTask<Integer> future = new FutureTask<Integer>(callable);　　// ----> Future接口代表 Callable接口里call()方法的返回值

        /* 3. 准备就绪，线程start */
        new Thread(future).start();

        try {

            Thread.sleep(5000);// 可能做一些事情

            System.out.println(future.get());　　// <---- 得到返回值

        } catch (InterruptedException e) {

            e.printStackTrace();

        } catch (ExecutionException e) {

            e.printStackTrace();

        }
}

}

public interface Executor {

　　void execute(Runnable command);

}

public class CallableAndFuture {

    public static void main(String[] args) {

        ExecutorService threadPool = Executors.newSingleThreadExecutor();　　   // ExecutorService继承自Executor，管理Thread对象

        Future<Integer> future = threadPool.submit(new Callable<Integer>() {　　// 线程池的线程提供了获取返回值future的服务。

            public Integer call() throws Exception {　　                        // 线程的执行体

                return new Random().nextInt(100);

            }
});

        try {

            Thread.sleep(5000);// 可能做一些事情

            System.out.println(future.get());

        } catch (InterruptedException e) {

            e.printStackTrace();

        } catch (ExecutionException e) {

            e.printStackTrace();

        }

    }

}

public class HeartBeat {

    public static void main(String[] args) {

        ScheduledExecutorService executor = Executors.newScheduledThreadPool(5);　　// <---- 有五个线程的线程池

        Runnable task = new Runnable() {

            public void run() {

                System.out.println("HeartBeat.........................");

            }

        };
executor.scheduleAtFixedRate(task,5,3, TimeUnit.SECONDS);   //5秒后第一次执行，之后每隔3秒执行一次

    }

}

public class ThreadPoolTest {

    public static void main(String[] args) throws InterruptedException {

     ExecutorService threadPool = Executors.newCachedThreadPool();//线程池里面的线程数会动态变化，并可在线程线被移除前重用

        for (int i = 1; i <= 3; i ++) {
final  int task = i;//TimeUnit.SECONDS.sleep(1);　　// 第六行！

            threadPool.execute(new Runnable() {    //接受一个Runnable实例

                public void run() {

                        System.out.println("线程名字： " + Thread.currentThread().getName() +  "  任务名为： "+task);

                }

            });
}

    }

}

// 输出：（为每个任务新建一条线程，共创建了3条线程）

线程名字： pool-1-thread-1 任务名为： 1

线程名字： pool-1-thread-2 任务名为： 2

线程名字： pool-1-thread-3 任务名为： 3

// 去掉第6行的注释其输出如下：（始终重复利用一条线程，因为newCachedThreadPool能重用可用线程）

线程名字： pool-1-thread-1 任务名为： 1

线程名字： pool-1-thread-1 任务名为： 2

线程名字： pool-1-thread-1 任务名为： 3

public class CompletionServiceTest {

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        ExecutorService executor = Executors.newFixedThreadPool(10);        //创建含10条线程的线程池

        CompletionService completionService = new ExecutorCompletionService(executor);

        for (int i =1; i <=10; i ++) {

            final  int result = i;

            completionService.submit(new Callable() {
public Object call() throws Exception {

                    Thread.sleep(new Random().nextInt(5000));   //让当前线程随机休眠一段时间

                    return result;

                }
});

        }

        System.out.println(completionService.take().get());   //获取执行结果

    }

}

   import java.util.Collections;   

   // 使用 java 7 排序

   private void sortUsingJava7(List<String> names){

      Collections.sort(names, new Comparator<String>() {

         @Override

         public int compare(String s1, String s2) {

            return s1.compareTo(s2);

         }

      });

   }

   // 上面的compare名字其实不重要
   // 也就侧面说明了匿名函数的必要性

   // 使用 java 8 排序

   private void sortUsingJava8(List<String> names){

      Collections.sort(names, (s1, s2) -> s1.compareTo(s2));

   }

package com.runoob.test;

import java.sql.*;

public class MySQLDemo {

    // JDBC 驱动名及数据库 URL

    static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";

    static final String DB_URL      = "jdbc:mysql://localhost:3306/RUNOOB";

    // 数据库的用户名与密码，需要根据自己的设置

    static final String USER = "root";

    static final String PASS = "123456";


    public static void main(String[] args) {

        Connection conn = null;

        Statement stmt  = null;

        try{

            // 1. 注册 JDBC 驱动

            Class.forName("com.mysql.jdbc.Driver");

            // 2. 打开链接

            System.out.println("连接数据库...");

            conn = DriverManager.getConnection(DB_URL,USER,PASS);

            // 3. 执行查询

            System.out.println(" 实例化Statement对象...");

            stmt = conn.createStatement();

            String sql;

            sql = "SELECT id, name, url FROM websites";

            ResultSet rs = stmt.executeQuery(sql);

            // 展开结果集数据库

            while(rs.next()){

                // 通过字段检索

                int    id   = rs.getInt("id");

                String name = rs.getString("name");

                String url  = rs.getString("url");

                // 输出数据

                System.out.print("ID: " + id);

                System.out.print(", 站点名称: " + name);

                System.out.print(", 站点 URL: " + url);

                System.out.print("\n");

            }

            // 完成后关闭

            rs.close();

            stmt.close();

            conn.close();

        }catch(SQLException se){

            // 处理 JDBC 错误

            se.printStackTrace();

        }catch(Exception e){

            // 处理 Class.forName 错误

            e.printStackTrace();

        }finally{

            // 关闭资源

            try{

                if(stmt!=null) 
                    stmt.close();

            }catch(SQLException se2){

            }// 什么都不做

            try{

                if(conn!=null) conn.close();

            }catch(SQLException se){

                se.printStackTrace();

            }

        }

        System.out.println("Goodbye!");

    }

}