/**
* This file is a simple example for java 
* @version 1.30 2020-05-11
* @author WangPengCheng
*/
public class Welcome
{
    public static void main (String [] args)
    {
        //创建字符串常量
        String greeting ="Welcome to Core Java";
        System.out.println(greeting);
        for(int i=0;i<greeting.length();++i)
        {
            System.out.print("=");
        }
        System.out.println();
    }

}

/* 导入相关的包和库 */
import java.awt.*;
import java.io.*;
import javax.swing.*;
/**
* A program for viewing images
* @version 1.30 2020-05-11 18\:25\:62
* @author WangPengCheng
*/

public class ImageViewer
{
    public static void main(String[] args)
    {
	//lambel表达式添加函数
        EventQueue.invokeLater(()->{
            JFrame frame=new ImageViewerFrame();
            frame.setTitle("ImageViewer");
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setVisible(true);
        });
    }
}
/*
 显示图片帧
*/
class ImageViewerFrame extends JFrame
{
    private JLabel label;
    private JFileChooser chooser;
    private static final int DEFAULT_WIDTH=300;
    private static final int DEFAULT_HEIGHT=400;
    //定义构造函数
    public ImageViewerFrame()
    {
        setSize(DEFAULT_WIDTH,DEFAULT_HEIGHT);
        //使用显示图片
        label=new JLabel();
        add(label);
        //设置文件夹当前路径
        chooser=new JFileChooser();
        chooser.setCurrentDirectory(new File("."));

        //设置文件选择框
        JMenuBar menuBar=new JMenuBar();
        setJMenuBar(menuBar);
        JMenu menu=new JMenu("File");
        menuBar.add(menu);
        //设置选框按钮
        JMenuItem openItem = new JMenuItem("Open");;
        menu.add(openItem);
        openItem.addActionListener(event->{
            //显示 选择弹窗
            int result=chooser.showOpenDialog(null);
            //根据选择设置icon
            if(result==JFileChooser.APPROVE_OPTION)
            {
                String name=chooser.getSelectedFile().getPath();
                label.setIcon(new ImageIcon(name));
            }
        });
        //设置关闭弹窗
        JMenuItem exitItem=new JMenuItem("Exit");
        menu.add(exitItem);
        exitItem.addActionListener(even->System.exit(0));
    }
}

//将所有方法作为static类型使用
import static java.lang.Math.*;
System.out.println("The square root of \uo3co is"+sqrt(PI));

int cp=sentence.codePointAt(i);
if(Character.isSupplementCodePoint(cp)){
    i+=2;
}else{
    ++i;
}

Scanner in=new Scanner(Path.get("myfile.txt"),"UTF-8");

int[] smallPrimes=new int[]{17,19,23,29};
//等同如下:
int[] anonymous={17,19,23,29};
smallPrimes=anonymous;

public class PrintStream
{
    public PrintStream printf(String fmt,Object... args){
        return format(fmt,args);
    }
    //注意：这里的Object实际上是一个object数组。
}

public static Object goodCopyOf(Object a,int newLength)
{
    Class cl=a.getClass();
    if(!cl.isArray()) return null;
    Class componenType=cl.getComponentType();
    int length=Array.getLength(a);
    Object newArray=Array.newInstance(componentType,newLength);
    System.arraycopy(a,0,newArray,0,Math.min(length,newLength));
    return newArray;
}

Method m1=Employee.class.getMethod("getName");
//执行函数

String n=(String)m1.invoke(harry);
Method squre=MethodTableTest.class.getMethod("square",double.class);
double y=(Double)squre.invoke(null,10);

 class LengthComparator implements Comparator<String>
 {
     public int compare(String first,String second){
         return first.length()-second.length();
     }
 }

 Comparator<String> comp=new LengthComparator();
 Arrays.sort(friends,new LengthComparator);

package clone;

import java.util.Date;
import java.util.GregorianCalendar;

public class Employee implements Cloneable
{
   private String name;
   private double salary;
   private Date hireDay;

   public Employee(String name, double salary)
   {
      this.name = name;
      this.salary = salary;
      hireDay = new Date();
   }

   public Employee clone() throws CloneNotSupportedException
   {
      // call Object.clone()
      Employee cloned = (Employee) super.clone();

      // clone mutable fields
      cloned.hireDay = (Date) hireDay.clone();

      return cloned;
   }

   /**
    * Set the hire day to a given date. 
    * @param year the year of the hire day
    * @param month the month of the hire day
    * @param day the day of the hire day
    */
   public void setHireDay(int year, int month, int day)
   {
      Date newHireDay = new GregorianCalendar(year, month - 1, day).getTime();
      
      // Example of instance field mutation
      hireDay.setTime(newHireDay.getTime());
   }

   public void raiseSalary(double byPercent)
   {
      double raise = salary * byPercent / 100;
      salary += raise;
   }

   public String toString()
   {
      return "Employee[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay + "]";
   }
}

package lambda;

import java.util.*;

import javax.swing.*;
import javax.swing.Timer;

/**
 * This program demonstrates the use of lambda expressions.
 * @version 1.0 2015-05-12
 * @author Cay Horstmann
 */
public class LambdaTest
{
   public static void main(String[] args)
   {
      String[] planets = new String[] { "Mercury", "Venus", "Earth", "Mars", 
            "Jupiter", "Saturn", "Uranus", "Neptune" };
      System.out.println(Arrays.toString(planets));
      System.out.println("Sorted in dictionary order:");
      Arrays.sort(planets);
      System.out.println(Arrays.toString(planets));
      System.out.println("Sorted by length:");
      //注意：没有定义输入类型
      Arrays.sort(planets, (first, second) -> first.length() - second.length());
      System.out.println(Arrays.toString(planets));
            
      Timer t = new Timer(1000, event ->
         System.out.println("The time is " + new Date()));
      t.start();   
         
      // keep program running until user selects "Ok"
      JOptionPane.showMessageDialog(null, "Quit program?");
      System.exit(0);         
   }
}

//传入参数，构造Person数组
Person[] people=stream.toArray(Person[]::new);

new SuperType(construction parameters)
{
    inner class methods and data;
}

package anonymousInnerClass;

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.Timer;

/**
 * This program demonstrates anonymous inner classes.
 * @version 1.11 2015-05-12
 * @author Cay Horstmann
 */
public class AnonymousInnerClassTest
{
   public static void main(String[] args)
   {
      TalkingClock clock = new TalkingClock();
      clock.start(1000, true);

      // keep program running until user selects "Ok"
      JOptionPane.showMessageDialog(null, "Quit program?");
      System.exit(0);
   }
}

/**
 * A clock that prints the time in regular intervals.
 */
class TalkingClock
{
   /**
    * Starts the clock.
    * @param interval the interval between messages (in milliseconds)
    * @param beep true if the clock should beep
    */
   public void start(int interval, boolean beep)
   {
       //创建匿名类
      ActionListener listener = new ActionListener()
         {
             //实现对应的函数
            public void actionPerformed(ActionEvent event)
            {
               System.out.println("At the tone, the time is " + new Date());
               if (beep) Toolkit.getDefaultToolkit().beep();
            }
         };
      Timer t = new Timer(interval, listener);
      t.start();
   }
}

package staticInnerClass;

/**
 * This program demonstrates the use of static inner classes.
 * @version 1.02 2015-05-12
 * @author Cay Horstmann
 */
public class StaticInnerClassTest
{
   public static void main(String[] args)
   {
      double[] d = new double[20];
      for (int i = 0; i < d.length; i++)
         d[i] = 100 * Math.random();
      ArrayAlg.Pair p = ArrayAlg.minmax(d);
      System.out.println("min = " + p.getFirst());
      System.out.println("max = " + p.getSecond());
   }
}

class ArrayAlg
{
   /**
    * A pair of floating-point numbers
    */
   public static class Pair
   {
      private double first;
      private double second;

      /**
       * Constructs a pair from two floating-point numbers
       * @param f the first number
       * @param s the second number
       */
      public Pair(double f, double s)
      {
         first = f;
         second = s;
      }

      /**
       * Returns the first number of the pair
       * @return the first number
       */
      public double getFirst()
      {
         return first;
      }

      /**
       * Returns the second number of the pair
       * @return the second number
       */
      public double getSecond()
      {
         return second;
      }
   }

   /**
    * Computes both the minimum and the maximum of an array
    * @param values an array of floating-point numbers
    * @return a pair whose first element is the minimum and whose second element
    * is the maximum
    */
   public static Pair minmax(double[] values)
   {
      double min = Double.POSITIVE_INFINITY;
      double max = Double.NEGATIVE_INFINITY;
      for (double v : values)
      {
         if (min > v) min = v;
         if (max < v) max = v;
      }
      return new Pair(min, max);
   }
}

package proxy;

import java.lang.reflect.*;
import java.util.*;

/**
 * This program demonstrates the use of proxies.
 * @version 1.00 2000-04-13
 * @author Cay Horstmann
 */
public class ProxyTest
{
   public static void main(String[] args)
   {
       //创建对象数组
      Object[] elements = new Object[1000];

      // fill elements with proxies for the integers 1 ... 1000
      //初始化数组
      for (int i = 0; i < elements.length; i++)
      {
         Integer value = i + 1;
         //创建代理处理句柄
         InvocationHandler handler = new TraceHandler(value);
         //创建代理对象，
         Object proxy = Proxy.newProxyInstance(null, /* 类加载器*/
         new Class[] { Comparable.class } , /* class对象数组 */
         handler/* 每个元素需要实现的接口 */
         );
         elements[i] = proxy;
      }

      // construct a random integer
      //生成一个随机数
      Integer key = new Random().nextInt(elements.length) + 1;

      // search for the key
      //执行二分搜索
      int result = Arrays.binarySearch(elements, key);

      // print match if found
      //输出找到结果
      if (result >= 0) System.out.println(elements[result]);
   }
}

/**
 * An invocation handler that prints out the method name and parameters, then
 * invokes the original method
 */
class TraceHandler implements InvocationHandler
{
   private Object target;

   /**
    * Constructs a TraceHandler
    * @param t the implicit parameter of the method call
    */
   public TraceHandler(Object t)
   {
      target = t;
   }
    //打印调用参数
   public Object invoke(Object proxy, Method m, Object[] args) throws Throwable
   {
      // print implicit argument
      System.out.print(target);
      // print method name
      System.out.print("." + m.getName() + "(");
      // print explicit arguments
      //输出参数
      if (args != null)
      {
         for (int i = 0; i < args.length; i++)
         {
            System.out.print(args[i]);
            if (i < args.length - 1) System.out.print(", ");
         }
      }
      System.out.println(")");

      // invoke actual method
      //绑定目标和参数
      return m.invoke(target, args);
   }
}