参数个数不同、类型不同、类型顺序不同，不定长参数…（不定长参数作为数组）

子类中的各类似方法的实现只需在父类中实现一次即可，所有继承父类的子类的对象都是父类的子对象，都可以调用父类中以父类对象为参数的方法，子类对象向上转型传入参数。

• 使用abstract关键字定义抽象类和抽象方法，抽象类不可以实例化对象，抽象方法没有方法体，因此抽象方法没有任何意义除非被重写，而承载这个抽象方法的抽象类必须被继承，因此不可能在非抽象类中定义抽象方法，抽象类除了被继承之外没有任何意义

• 由于继承抽象类必须要实现抽象类中的所有抽象方法，但是有些子类并不需要实现其中的抽象方法，Java不能同时继承多个父类，就有了接口的概念。接口是抽象类的延伸，接口中的所有方法都没有方法体。

• 使用interface关键字定义接口，可以像类一样使用权限修饰符，public关键字仅限用于与其同名的文件中被定义，接口中的方法必须被定义为public或abstract形式，即使不声明为public，它也是public

  • 接口中定义的任何字段都自动式static和final的
  • 实现接口时使用implements，多个接口使用逗号个卡尼
  • 接口也可以被接口继承，使用extends

  package ex10_Interface;

  interface drawTest { //定义接口
  void draw(); //定义方法,省略了public和abstract，其他不被编译器认可
  }

  interface drawTest2 extends drawTest {
  void draw2(); //接口的继承
  }

  class A {
  }

  class B extends A implements drawTest { //多个接口使用逗号隔开
  public void draw() { //由于该类实现了接口需要覆盖接口定义的方法
  System.out.println("B类继承A类，实现接口drawTest，B.draw()");
  }
  }

  class C extends A implements drawTest {
  public void draw() {
  System.out.println("C类继承A类，实现接口drawTest，C.draw()");
  }
  }

  public class UseInterface {
  public static void main(String[] args) {
  System.out.println("----------------------------");
  drawTest inf = new B(); //接口也可以进行向上转型
  drawTest inf2 = new C();
  inf.draw();
  inf2.draw();
  B b = new B(); //也可以直接使用对象调用成员方法
  b.draw();
  }
  }

11 类的高级特性

• 使用package 定义包名，通常使用Internet域名的反序作为包名

• 使用import导入包，导入包中所有类import com.lzw.*; 但并不会指定这个包的子包的所有类。 或者导入指定类import com.lzw.Math;

• 同一个包中的类可以不放在同一个位置，只要在CLASSPATH中指定了路径

• 使用import static导入静态成员（JDK5）

• final定义的变量必须在声明时对其赋值，除了修饰基本的数据类型，还可以修饰对象引用，如数组，一旦一个对象使用final修饰，它只能恒定指向一个对象，无法将其改变指向另一个对象。一个既是static有时final的字段是一段不能改变的存储空间

• final定义的常量使用大写字母命名，中间使用下划线。final定义的变量不可改变，定义的引用不可改变，但是引用的值可以改变

• final定义的值并不是恒定不变的，例如创建空白final值，在构造方法中对其赋值；对final成员变量赋值为随机值，每次创建新的对象都会有一个随机的final成员变量值（本质上是创建了新的对象，新的对象有了新的final值）

• final可以修饰的数据

  • final修饰成员变量不可更改
  • final修饰成员变量定义为空白final，在构造方法中为空白final赋值
  • final参数，方法内不可改变参数的值
  • 方法内部设置局部变量为final，不可改变其值

  package ex11_AdvancedClass;

  import static java.lang.System.out;
  import static java.lang.System.setOut;

  import java.nio.file.FileAlreadyExistsException;
  import java.util.Random;

  class Test {
  int i = 0;
  }

  public class FinalData {
  private static Random rand = new Random(); //实例化一个Random类对象
  private final int VALUE_1 = 9; //声明一个静态final常量，每个对象都有一份
  private final static int VALUE_2 = 10; //声明一个final,static常量，归属于类，只有一份
  private final Test test = new Test(); //声明一个final引用
  private Test test2 = new Test(); //声明一个不是final的引用
  private final int[] a = {1, 2, 3, 4}; //声明一个定义为final的数组
  private final int a1 = rand.nextInt(10);
  private final static int a2 = rand.nextInt(10);

  private final int x;  //定义空白final，可在构造方法中初始化
  
  public FinalData(int y) {
      x = y;  //初始化空白final值
  }
  
  public static void main(String[] args) {
      FinalData data = new FinalData(1);

  // data.test = Test(): //使用final修饰的引用不可改变指向
  data.test.i = 5; //不可改变引用，但可以改变引用的值（指向不可变，指向的内容可变）
  data.test2 = new Test(); //没有使用final修饰的引用可以改变指向
  // data.VALUE_1++; //使用final修饰的变量不可改变
  // data.VALUE_2++; //使用final修饰的静态变量不可改变,一般使用FinalData.VALUE调用
  data.a[0] = 9; //不可改变引用，但可以改变引用的值
  out.println(data.a[0]);

      //其中的final x，a1随着新对象的创建都会改变
      //a2为final static，再次创建新对象并不会创建新区域，仍指向初始化时的区域，值也不会改变
      out.println("static a2: " + FinalData.a2);
      FinalData fdata = new FinalData(1);
      out.println("fdata.a1: " + fdata.a1 + " static fdata.a2: " + fdata.a2 + " fdata.x " + fdata.x);
      FinalData fdata2 = new FinalData(2);
      out.println("fdata2.a1: " + fdata2.a1 + " static fdata2.a2: " + fdata.a2 + " fdata2.x " + fdata2.x);
  
  }

  }

• final定义的方法不能被重写，是因为就是定义为不能重写

• pravite定义的方法也不能被重写，是因为不能被类以外的区域访问，所以不能重写

  • 区别：pravite定义的方法被隐式的指定为final类型，final类型指定的方法不能被重写但是可以被子类对象向上转型后调用。pravite类型指定的方法被子类对象向上转型后不可调用，因为pravite就是定义了不能被本类以外的区域访问，子类也不可以

final定义的类不允许被继承，类中的所有方法都被隐式的设置为final形式，但是类中的成员变量可以定义为final或非final形式

• 成员内部类简介

  • 内部类可以随意使用外部类的成员变量和方法，即使是private
  • 内部类的对象必须绑定到外部类的对象上，内部类的对象与外部类的对象是相互依赖的
  • 实例化内部对象时不能在new操作符之前使用外部类名称实例化内部类对象，而是使用外部类的对象创建其内部类的对象

• 内部类向上转型为接口

  • 在内部类中实现接口，定义改该内部类为private类型（非内部类不可以定义为private或protected），在外部类中定义一个public方法，该方法返回接口类型，返回对象时内部类对象，这样就实现了内部类对象向上转型为接口。如果某个类继承了外部类
  • 非内部类不能被声明为private或protected

• 使用this关键字获取内部类和外部类的引用

  • 在内部类中使用this调用内部类对象的引用
  • 使用外部类.this调用外部类对象的引用

• 局部内部类：在成员方法内定义内部类，如果需要在方法体内使用局部变量，需要设置成final类型，也即是在方法体内定义的内部类只能访问方法中final类型的局部变量，在内部类中，局部变量的值不可以改变。

• 匿名内部类：创建一个实现接口的匿名类的对象，在匿名内部类定义结束后需要加分号标识，标识创建接口引用表达式的标识。

• 静态内部类：内部类被声明为static

  • 如果创建静态内部类的对象，不需要外部类的对象
  • 不能从静态内部类的对象中访问非静态外部类的对象
  • 如果在每一个java文件中都设置一个主方法，将出现很多额外代码，而程序本身不需要这些主方法，为了解决这个问题，可以将主方法写入一个静态内部类中，编译后将生成一个名为<外部类$内部类>的独立类和<外部类>，只要使用<外部类$内部类>就可以运行主方法中的内容，完成测试后，需要将所有的class文件打包时只要伸出这个独立类即可

  //成员内部类
  package ex11_AdvancedClass;

  public class OuterClass { //外部类
  innerClass in = new innerClass(); //在外部类实例化内部类的对象引用

  public void outf() {
      in.inf();  //在外部类中调用内部类方法
  }
  
  public innerClass doit() {  //外部类方法
      //y=4;  //外部类不可以直接访问内部类的成员变量
      in.y = 4;  //可以通过对象访问
      return new innerClass();  //返回内部类的引用
  }
  
  class innerClass {  //内部类
      int y = 0;  //内部类成员变量
  public innerClass() {
  }  //内部类构造方法
  
  public void inf() {
  }  //内部类成员方法
  }
  
  public static void main(String[] args) {
      OuterClass out = new OuterClass();
      //内部类的对象实例化必须在外部类或外部类的非静态方法中实现
      //在其他地方实现需要使用外部类。
      //内部类实例一定要绑定到外部类的实例上，内部类对象依赖于外部类对象
      OuterClass.innerClass in3 = out.doit();  //out对象返回内部类的引用赋值给in
      //不能在new之前使用外部类名称实例化内部类对象，应该使用外部类的对象创建内部类的对象
      OuterClass.innerClass in2 = out.new innerClass();  //out对象创建一个新对象赋值给in2
      System.out.println(in3.y);
      System.out.println(out.in);
      System.out.println(out.in.y);  //out对象调用过doit()方法，把它的y值设置成了4
  }

  }

  //内部类向上转型为接口
  package ex11_AdvancedClass;

  interface OutInterface {
  public void f();
  }

  public class InterfaceInner {
  public static void main(String[] args) {
  OuterClass2 out = new OuterClass2(); //创建外部类对象
  OutInterface outinter = out.doit(); //使用外部类对象调用方法，返回内部类对象向上转型的接口
  outinter.f(); //使用接口调用f()方法
  }
  }

  class OuterClass2 {
  //定义一个内部类实现OuterInterface接口
  private class InnerClass implements OutInterface {
  public InnerClass(String s) { //内部类的构造方法
  System.out.println(s);
  }

      public void f() {
          System.out.println("访问内部类的f()方法");
      }
  }
  
  public OutInterface doit() {  //定义一个外部类方法，返回值类型为OuterInterface接口类型
      return new InnerClass("访问内部类构造方法");  //内部类向上转型为接口
  }

  }

  //局部内部类
  package ex11_AdvancedClass;

  interface OutInterface2 {

  }

  class OuterClass3 {
  public OutInterface2 doit(String x) {
  //在doit()方法内定义一个内部类
  class InnerClass2 implements OutInterface2 {
  InnerClass2(String s) {
  s = x; //内部类中使用局部变量必须是final变量或者实际上的final变量（不可变）
  System.out.println(s);
  }
  }
  return new InnerClass2("doit");
  }
  }

  public class Test2 {
  public static void main(String[] args) {
  OuterClass3 out3 = new OuterClass3();
  OutInterface2 outint = out3.doit("hi");

  }

  }

  //匿名内部类，创建一个实现接口的匿名类的对象
  class OuterClass4 {
  public OutInterface2 doit() { //定义doit()方法
  return new OutInterface2() { //声明匿名内部类
  private int i = 0;
  public int getValue() { //实现接口
  return i;
  }
  }; // 在匿名内部类定义结束后需要加分号标识，
  }
  }

12 异常处理

try-catch-finally

• e.getMessage(); 输出错误性质

• e.toString(); 输出类型和性质

• e.printStackTrack(); 指出异常的类型、性质、栈层次及出现在程序中的位置

• catch异常按顺序进行捕捉

  package ex12_Exception;

  public class Take {
  public static void main(String[] args) {
  try { //try语句中包含可能出现异常的代码
  String str = "hi";
  System.out.println("str: " + str);
  int age = Integer.parseInt("20L");
  System.out.println("age: " + age);
  } catch (Exception e) { //获取异常信息
  e.printStackTrace(); //输出异常性质
  }
  System.out.println("program over");
  }
  }

package ex12_Exception;

class MyException extends Exception {  //创建自定义异常，继承Exception
    public MyException(String ErrorMessage) {  //构造方法
        super(ErrorMessage);  //父类构造方法
    }
}

public class Tran {
    static int avg(int number1, int number2) throws MyException {
        if (number1 < 0 || number2 < 0) {  //判断是否满足条件
            throw new MyException("不可使用负数");  //抛出异常信息
        }
        if (number1 > 100 || number2 > 100) {
            throw new MyException("数值太大了");
        }
        return (number1 + number2) / 2;
    }

    public static void main(String[] args) {
        try {  //处理可能出现异常的代码
            int result = avg(102, 150);  //调用avg()方法
            System.out.println(result);
        } catch (MyException e) {
            System.out.println(e);  //输出异常信息
        }

    }
}

Java类库的每个包中都定义了异常，所有这些类都是Throwable的子类，Throwable派生出两个子类，Exception类和Error类

13 Swing程序设计

Swing组件的窗体通常与组件和容器相关，所以在JFrame对象创建完成后，需要调用getContentPane()方法将窗体转换为容器，然后在容器中添加组件或设置布局管理器。这个容器用来包含和显示组件，使用Container.add()方法添加组件至容器。使用Container.remove()删除组件。

• JFrame窗体，继承JFrame类

  • 构造方法
  • JFrame(); 初始化不可见、没有标题
  • JFrame(String title); 不可见、有标题，使用setVisible(true); 可见
  • 窗体关闭类型
  • DO_NOTHING_ON_CLOSE
  • DISPOSE_ON_CLOSE
  • HIDE_ON_CLOSE
  • EXIT_ON_CLOSE

• JDialog窗体，继承JDialog类

  • 构造方法
  • JDialog();没有标题和父窗体
  • JDialog(Frame f); 指定父窗体的对话框
  • JDialog(Frame f, boolean model); 指定父窗体和指定类型的对话框
  • JDialog(Frame f, String title); 指定父窗体和标题
  • JDialog(Frame f, String title, boolean model); 指定父窗体、标题和类型

  package ex13_Swing;

  import javax.swing.; import java.awt.;

  public class Example1 extends JFrame { //定义一个类继承JFrame
  public void CreateJFrame(String title) { //定义一个CreateJFrame方法
  JFrame jf = new JFrame(title); //实例化一个JFrame对象
  Container container = jf.getContentPane(); //获取一个容器
  JLabel jl = new JLabel("这是一个JFrame窗体"); //创建一个JLabel标签
  jl.setHorizontalAlignment(SwingConstants.CENTER); //使标签上的文字居中
  container.add(jl); //将标签添加到容器中
  container.setBackground(Color.white); //设置容器的背景颜色
  jf.setVisible(true); //使窗体可见
  jf.setSize(200, 150); //设置窗体大小
  jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); //设置窗体关闭方式
  }

  public static void main(String[] args) {
      new Example1().CreateJFrame("创建一个JFrame窗体");
  }

  }

  package ex13_Swing;

  import javax.swing.; import java.awt.;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;

  public class MyJDialog extends JDialog { //创建新类继承JDialog
  public MyJDialog() { //构造方法
  super(new MyFrame(), "第一个JDialog窗体", true); //实例化一个JDialog对象，指定对话框的父窗体，窗体标题和类型
  Container container = getContentPane(); //创建一个容器
  container.add(new JLabel("这是一个对话框")); //在容器中添加标签
  setSize(100, 100);
  }

  public static void main(String[] args) {
      new MyJDialog();
  }

  }

  class MyFrame extends JFrame {

  public MyFrame() {
      Container container = getContentPane();  //创建一个容器
      container.setLayout(null);
      JLabel jl = new JLabel("这是一个JFrame窗体");  //在窗体中设置标签
      jl.setHorizontalAlignment(SwingConstants.CENTER);  //设置标签的位置
      container.add(jl);
      JButton bl = new JButton("弹出对话框");  //定义一个按钮
      bl.setBounds(10, 10, 100, 21);
      bl.addActionListener(new ActionListener() {  //为按钮添加鼠标单击事件
          @Override
          public void actionPerformed(ActionEvent e) {
              new MyJDialog().setVisible(true);
          }
      });
      container.add(bl);  //将按钮添加到容器中
      container.setBackground(Color.white);  //设置容器的背景颜色
      setSize(200, 200);
      setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
      setVisible(true);
  }

  }

• JLabel构造方法

  • JLabel(); 不带图标和文本
  • JLabel(Icon icon); 带图标
  • JLabel(Icon icon, int aligment); 带图标、水平对齐方式
  • JLabel(String text, int aligment); 带文本、水平对齐方式
  • JLabel(String text, Icon icon, int aligment); 文本、图标、水平对齐方法

• 使用图片图标 javax.swing.ImageIcon类

  • java.lang.Class类中的getResource()方法可以获取资源文件中的URL路径

  //图标的使用
  package ex13_Swing;

  import javax.swing.; import java.awt.;

  public class DrawIcon implements Icon { //实现Icon接口
  private int width; //声明图标的宽
  private int height; //声明图标的高

  public int getIconWidth() {  //实现getIconWidth()方法
      return this.width;
  }
  
  public int getIconHeight() {  //实现getIconHeight()方法
      return this.height;
  }
  
  public DrawIcon(int width, int height) {  //构造方法
      this.width = width;
      this.height = height;
  }
  
  public void paintIcon(Component arg0, Graphics arg1, int x, int y) {
      arg1.fillOval(x, y, width, height);  //绘制一个图形
  }
  
  public static void main(String args[]) {
      JFrame jf = new JFrame();  //创建一个JFrame窗口
      Container container = jf.getContentPane();  //创建一个容器
      container.setBackground(Color.white);
      jf.setVisible(true);
      jf.setSize(200,150);
      jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
  DrawIcon icon = new DrawIcon(15,15);  //创建标签对象
  //创建一个标签，设置标签上的文字在标签正中间
  JLabel jl = new JLabel("测试12345566661111111", icon, SwingConstants.CENTER);
  container.add(jl);  //添加到容器
  }

  }

  //图片图标
  package ex13_Swing;

  import javax.swing.; import java.awt.;
  import java.net.URL;

  public class MyImageIcon {
  public static void main(String[] args) {
  JFrame jf = new JFrame("hi"); //创建窗体对象
  Container container = jf.getContentPane(); //创建容器
  JLabel jl = new JLabel("这是一个JFrame窗体", JLabel.CENTER); //创建标签
  //创建图标图片的url，图片方法class文件夹下
  URL url = MyImageIcon.class.getResource("imageButton.jpg");
  Icon icon = new ImageIcon(url); //创建图标
  jl.setIcon(icon); //为标签设置图标
  jl.setHorizontalAlignment(SwingConstants.CENTER); //设置文字放在标签中间
  jl.setOpaque(false); //设置标签为不透明
  container.add(jl); //将标签添加至容器

      jf.setSize(500,500);
      jf.setVisible(true);
      jf.setBackground(Color.blue);
      jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
  }

  }

• 绝对布局

  • Container.setLayout(null); 取消布局管理器
  • Container.setBound(); 设置每个容器、组件的大小和位置

• 流布局管理器

  • FlowLayout(int alignment, int horizGap, int vertGap);
  • jf.setLayout(fl)

• 边界布局管理器（Swing默认）

  • 使用add方法同时设置位置和添加组件

• 网格布局管理器

  • GridLayout(int rows, int columns, int horizGap, int vertGap); 类似于流布局管理器的使用

  //流布局管理器
  package ex13_Swing;

  import javax.swing.; import java.awt.;

  public class FlowLayoutPosition {
  public static void main(String[] args) {
  JFrame jf = new JFrame("title"); //创建JFrame对象
  Container container = jf.getContentPane(); //创建容器
  //设置jf参数
  jf.setVisible(true);
  jf.setSize(500,500);
  jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
  //创建流布局管理器对象，设置对齐方式，水平间隔，垂直间隔
  FlowLayout fl = new FlowLayout(FlowLayout.RIGHT, 10,10);
  jf.setLayout(fl);
  for (int i = 0; i < 100; i++) {
  JButton jb = new JButton("button "+ i); //创建JButton对象
  container.add(jb); //添加到容器
  }
  }
  }

  //边界布局管理器
  package ex13_Swing;

  import javax.swing.; import java.awt.;

  public class BorderLayoutPosition {
  public static void main(String[] args) {
  JFrame jf = new JFrame("title"); //创建JFrame对象
  Container container = jf.getContentPane(); //创建容器
  //设置jf参数
  jf.setVisible(true);
  jf.setSize(500, 500);
  jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
  BorderLayout bl = new BorderLayout();
  jf.setLayout(bl); //默认边界布局，可以不写
  //边界布局管理器，上、下、左、右、中
  String[] border = {
  BorderLayout.CENTER,
  BorderLayout.NORTH,
  BorderLayout.SOUTH,
  BorderLayout.WEST,
  BorderLayout.EAST};
  String[] buttonName = {"center", "north", "south", "west", "east"};
  for (int i = 0; i < border.length; i++) {
  JButton jb = new JButton(buttonName[i]);
  container.add(border[i], jb); //add()方法可以同时添加布局和组件
  }
  }

  }

面板也是一个Swing容器，继承自java.awt.container类，可以容纳其他组件，但它也必须被添加到其他容器中

• JPanel面板

• JScrollPane面板 带滚动条，也是一种容器，但是只能放一个组件，不可以使用布局管理器，如果需要多个组件，需要将多个组件放在JPanel面板上，然后将JPanel面板作为一个整体添加在JScrollPane上

  //JPanel面板
  package ex13_Swing;

  import javax.swing.; import java.awt.;

  public class JPanelTest extends JFrame {
  public JPanelTest() {
  Container c = getContentPane();
  //将整个容器设置成2行1列的网格布局
  c.setLayout(new GridLayout(2, 2, 10, 10));
  //初始化面板，设置面板布局
  JPanel jp1 = new JPanel(new GridLayout(1, 4, 10, 10));
  JPanel jp2 = new JPanel(new GridLayout(1, 3, 10, 10));
  JPanel jp3 = new JPanel(new GridLayout(1, 2, 10, 10));
  JPanel jp4 = new JPanel(new GridLayout(1, 5, 10, 10));
  jp1.add(new JButton("1")); //在面板中添加按钮
  jp1.add(new JButton("2"));
  jp1.add(new JButton("3"));
  jp1.add(new JButton("4"));
  jp2.add(new JButton("21"));
  jp3.add(new JButton("31"));
  jp3.add(new JButton("32"));
  jp4.add(new JButton("41"));
  jp4.add(new JButton("42"));
  jp4.add(new JButton("43"));
  c.add(jp1); //添加面板到容器
  c.add(jp2);
  c.add(jp3);
  c.add(jp4);
  setVisible(true);
  setSize(500, 500);
  setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
  }

  public static void main(String[] args) {
      new JPanelTest();
  }

  }

  //JScroll面板
  package ex13_Swing;

  import javax.swing.; import java.awt.;

  public class JScrollPaneTest extends JFrame {
  public JScrollPaneTest() {
  Container c = getContentPane();
  JTextArea jta = new JTextArea(20, 50); //创建文本区域组件
  JScrollPane jsp = new JScrollPane(jta); //创建JScrollPane面板对象，将文本区域组件添加上
  c.add(jsp);
  setTitle("带滚动条的文本编辑器");
  setSize(500, 500);
  setVisible(true);
  setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
  }

  public static void main(String[] args) {
      new JScrollPaneTest();
  }

  }

• JButton(String text, Icon icon); 提交按钮组件

• JRadioButton(); 单选按钮组件，将所有按钮添加到一个面板中，在将面板添加到容器中，所有按钮添加到组才是单选

• JCheckBox(); 将多个复选框添加到一个面板中，也可以为每个复选框添加监听事件

  //提交按钮、单选按钮
  package ex13_Swing;

  import javax.swing.; import javax.swing.border.TitledBorder; import java.awt.;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.net.URL;

  public class JButtonTest extends JFrame {
  public JButtonTest() {
  Container c = getContentPane();
  URL url = JButtonTest.class.getResource("imageButton.jpg");
  Icon icon = new ImageIcon(url);
  //设置布局3行2列，间隔为5
  setLayout(new GridLayout(5, 1, 5, 5));
  JButton jb1 = new JButton("button1", icon);
  JButton jb2 = new JButton("button2", icon);
  JButton jb3 = new JButton("button3", icon);
  JButton jb4 = new JButton(); //实例化一个没有文字的按钮
  add(jb1);
  add(jb2);
  add(jb3);
  add(jb4);
  jb2.setEnabled(false); //设置按钮不可用
  jb4.setMaximumSize(new Dimension(10, 10));//设置按钮与图片大小相同
  jb4.setIcon(icon); //为按钮设置图标
  jb4.setHideActionText(true);
  jb4.setToolTipText("图片按钮"); //设置按钮的提示文字，鼠标指向按钮时
  jb4.setBorderPainted(false); //设置图标按钮边界不显示
  jb4.addActionListener(new ActionListener() { //为按钮添加监听事件
  @Override
  public void actionPerformed(ActionEvent e) {
  //弹出确认对话框
  JOptionPane.showMessageDialog(null, "弹出对话框");
  }
  });
  //单选按钮组件
  JRadioButton jrb1 = new JRadioButton();
  JRadioButton jrb2 = new JRadioButton();
  JRadioButton jrb3 = new JRadioButton();
  ButtonGroup bg = new ButtonGroup(); // 添加到组后才是单选按钮
  bg.add(jrb1);
  bg.add(jrb2);
  bg.add(jrb3);
  JPanel jp = new JPanel(); //创建面板
  jp.add(jrb1);
  jp.add(jrb2);
  jp.add(jrb3);
  jp.setBorder(new TitledBorder("TitleBorder"));
  add(jp);

      setVisible(true);
      setSize(500, 500);
      setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
  }
  
  public static void main(String[] args) {
      new JButtonTest();
  }

  }

  //复选框组件
  package ex13_Swing;

  import javax.swing.; import java.awt.;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;

  public class CheckBoxTest extends JFrame {
  public CheckBoxTest() {
  Container c = getContentPane(); //创建容器
  setLayout(new BorderLayout());
  JPanel jp1 = new JPanel(); //创建面板
  JPanel jp2 = new JPanel();

      JCheckBox jc1 = new JCheckBox("1");  //创建复选框
      JCheckBox jc2 = new JCheckBox("2");
      JTextArea jt = new JTextArea(20, 20);  //创建编辑器
      final JScrollPane jsp1 = new JScrollPane(jt);  //创建滑动面板
  jp1.add(jsp1);  //面板1添加编辑器
  jp2.add(jc1);  //面板2添加复选框
  jp2.add(jc2);  //面板2添加复选框
  jc1.addActionListener(new ActionListener() {  //复选框添加监听事件
      @Override
      public void actionPerformed(ActionEvent e) {
          jt.append("复选框1被选中\n");
      }
  });
  jc2.addActionListener(new ActionListener() {
      @Override
      public void actionPerformed(ActionEvent e) {
          jt.append("复选框2被选中\n");
      }
  });
  
  c.add(jp1, BorderLayout.NORTH);  //添加面板到容器
  c.add(jp2, BorderLayout.SOUTH);
  
  setSize(500, 500);
  setVisible(true);
  setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
  }
  
  public static void main(String[] args) {
      new CheckBoxTest();
  }

  }

• 下拉列表组件

  • JComboBox()，下拉列表中的项目可以封装为JComBoxModel类型、数组或Vector

• 列表框组件

  • JList()，数组、Vector类型和ListModel类型

• 文本框组件

  • JTextField()

• 密码框组件

  • JPasswordField()

• 文本域组件

  • JTextArea(); 类中存在一个setLineWrap()方法，设置为true表示自动换行

• 动作监听事件

  • addActionListener(new jbAction); 在内部类jbAction中实现ActionListener接口，重写actionPerformed方法
  • addActionListener(new ActionListen() {
    public void actionPerformed(ActionEvent arg0) {
    //do something
    }}); 使用匿名内部类实现

• 交点监听事件

  • addFocusListener(new FocusListener() {
    public void focusLost(FocusEvent arg0) {  //组件失去焦点时调用的方法
    // do something
    }
    public void focusGained(FocusEvent arg0) //组件获取焦点时调用的方法
    })；

14 集合类

• List和Set接口都继承了Collection接口，因此这些方法对List和Set集合是通用的
• 遍历通过iterator()方法返回迭代器，Iterator的next()返回的是Object

• 允许重复，有序，可用索引查询

• LIst接口继承了Collection接口，包含Collection中的所有方法，还包括两个重要的方法get(int index); 获取指定位置元素set(int index, Object obj); 将集合中指定位置对象修改为指定的对象

• 实例化List集合

  • List list = new ArrayList<>();  可以根据索引快速随机访问，插入、删除删除速度慢
  • List list = new LinkedList<>();  随机访问速度慢，插入、删除速度快

  package ex14_Collection;

  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.List;

  public class Muster {
  public static void main(String args[]) {
  Collection list = new ArrayList<>(); //实例化集合类对象
  list.add("a");
  list.add("b");
  list.add("c");
  Iterator it = list.iterator(); //创建迭代器
  while (it.hasNext()) { //判断是否还有下一个元素
  String str = (String) it.next(); //获取集合中的元素
  System.out.println(str);
  }

      //随机获取一个字母，删除索引为2的元素
      List<String> list1 = new ArrayList<>();  //创建集合对象
      list1.add("1");
      list1.add("2");
      list1.add("2");
      int i = (int) (Math.random() * list.size());
      System.out.println("随机访问：" + list1.get(i));
      list1.remove("2"); // 删除对象
      list1.remove(1);  //删除索引位置的对象
      for (int j = 0; j < list1.size(); j++) {  //遍历集合
          System.out.print(list1.get(j) + " ");
      }
  }

  }

• 不能重复，无序

• Set接口常用的实现类有HashSet类和TreeSet类

  • HashSet不保证Set的迭代顺序，允许使用null元素
  • TreeSet实现了Set接口，还实现了java.util.SortedSet接口，TreeSet类实现的Set集合在遍历时按照自然顺序递增排序，也可以按照指定比较器排序

• 存入TreeSet类实现的Set集合必须实现Comparable接口，该接口中的compareTo(Object o)方法比较此对象与指定对象的顺序

package ex14_Collection;

import java.util.Iterator;
import java.util.TreeSet;

public class UpdateStu implements Comparable<Object> {  //创建类实现Comparable接口
    String name;
    long id;

    public UpdateStu(String name, long id) {
        this.name = name;
        this.id = id;
    }

    public int compareTo(Object o) {
        UpdateStu upstu = (UpdateStu) o;
        int result = id > upstu.id ? 1 : (id == upstu.id ? 0 : -1);
        return result;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public static void main(String[] args) {
        UpdateStu stu1 = new UpdateStu("李同学", 1011);
        UpdateStu stu2 = new UpdateStu("陈同学", 1021);
        UpdateStu stu3 = new UpdateStu("王同学", 1031);
        UpdateStu stu4 = new UpdateStu("马同学", 1041);
        TreeSet<UpdateStu> tree = new TreeSet<>();
        tree.add(stu1);
        tree.add(stu2);
        tree.add(stu3);
        tree.add(stu4);
        Iterator<UpdateStu> it = tree.iterator();  //Set集合中的所有对象的迭代器
        System.out.println("Set中所有元素:");
        while (it.hasNext()) {  //遍历集合
            UpdateStu stu = (UpdateStu) it.next();
            System.out.println(stu.getId() + " " + stu.getName());
        }

        it = tree.headSet(stu2).iterator();  //截取stu2之前的对象
        System.out.println("截取前面部分的集合：");
        while (it.hasNext()) {  //遍历集合
            UpdateStu stu = (UpdateStu) it.next();
            System.out.println(stu.getId() + " " + stu.getName());
        }

        it = tree.subSet(stu2, stu4).iterator();  //截取stu2-stu4之间的对象
        System.out.println("截取中间部分的集合：");
        while (it.hasNext()) {  //遍历集合
            UpdateStu stu = (UpdateStu) it.next();
            System.out.println(stu.getId() + " " + stu.getName());
        }

    }

}

• Map接口没有继承Collection接口，提供的是key到value的映射，Map中不能包含相同的key
• Map接口常用的实现类有HashMap和TreeMap
  • HashMap是基于哈希表的Map接口的实现，添加删除映射关系效率高，允许使用null值和null键，不保证映射顺序
  • TreeMap不仅实现了Map接口，还实现了java.util.SortedMap接口，集合中的映射关系有一定的顺序，因此键不允许为null，添加删除映射关系效率低
  • keySet()返回Set集合，values返回Collection集合
• 可以通过HashMap创建Map集合，当需要顺序输出时，再创建一个完成相同映射关系的TreeMap类实例

package ex14_Collection;

import java.util.*;

public class UpdateStu2 {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();  //创建Map实例
        map.put("01", "李同学");  //向集合中添加对象
        map.put("02", "魏同学");
        map.put("03", "魏同学");
        map.put("04", null); //会被打印出来
        Set<String> set = map.keySet();  //构建Map集合中所有key对象的集合
        Iterator<String> it = set.iterator();  //创建集合迭代器
        System.out.println("key集合中的元素：");
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        Collection<String> coll = map.values();  //构建Map集合中所有values值的集合
        it = coll.iterator();
        System.out.println("values集合中的元素");
        while (it.hasNext()) {
            System.out.println(it.next());
        }

    }
}

package ex14_Collection;

public class Emp {
    private String e_id;
    private String e_name;

    public Emp(String e_id, String e_name) {
        this.e_id = e_id;
        this.e_name = e_name;
    }

    public String getE_id() {
        return e_id;
    }

    public String getE_name() {
        return e_name;
    }

    public void setE_id(String e_id) {
        this.e_id = e_id;
    }

    public void setE_name(String e_name) {
        this.e_name = e_name;
    }
}


package ex14_Collection;

import java.util.*;

public class MapText {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();

        Emp emp = new Emp("351", "张三");  //创建Emp对象
        Emp emp2 = new Emp("512", "李四");
        Emp emp3 = new Emp("853", "王一");
        Emp emp4 = new Emp("125", "赵六");
        Emp emp5 = new Emp("341", "黄七");

        map.put(emp.getE_id(), emp.getE_name());  //添加对象到集合中
        map.put(emp2.getE_id(), emp2.getE_name());
        map.put(emp3.getE_id(), emp3.getE_name());
        map.put(emp4.getE_id(), emp4.getE_name());
        map.put(emp5.getE_id(), emp5.getE_name());

        Set<String> set = map.keySet();  //获取Map集合中的key对象集合
        Iterator<String> it = set.iterator();
        System.out.println("HashMap集合类实现的Map集合，无序：");
        while (it.hasNext()) {
            String str = (String) it.next();
            String name = (String) map.get(str);
            System.out.println(str + " " + name);
        }

        TreeMap<String, String> treeMap = new TreeMap<>();  //创建TreeMap集合对象
        treeMap.putAll(map);
        Iterator<String> iter = treeMap.keySet().iterator();
        System.out.println("TreeMap类实现的Map集合，键值升序：");
        while (iter.hasNext()) {
            String str = (String) iter.next();
            String name = treeMap.get(str);
            System.out.println(str + " " + name);
        }

    }
}

15 I/O（输入/输出）

java定义了许多专门负责各种方式的输入/输出，都放在java.io包中

输入流：抽象类：InputStream（字节输入流），Reader（字符输入流）

输出流：抽象类：OutputStream（字节输出流），Writer（字符输出流）

• read(); 从输入流中读取数据的下一个字节。返回0-255范围内的int字节值，没有可用的字节则返回值为-1

• read(byte[] b); 从输入流中读取一定长度的字节，并以整数的形式返回字节数

• mark(int readlimit); 在输入流的当前位置放一个标记，readlimit参数告知此输入流在标记位置失效前允许读取的字节数

• reset(); 将输入指针返回到当前所做的标记处

• skip(long n); 跳过输入流上的n个字节并返回实际跳过的字节

• markSupport(); 如果当前流支持mark()/reset()操作就返回true

• close(); 关闭此输入流并释放与该流关联的所有系统资源

  • 并不是所有的InputStream类都支持InputStream中定义的所有方法，如skip()，mark()，reset()等方法只对某些子类有用

• File类是java.io包中唯一代表磁盘文件本身的对象

• 构造方法有三种

  • new File(String);
  • new File(String father, String child);
  • new File(File f, String child);

package IO;

import java.io.File;

public class FileTest {
    public static void main(String[] args) {
        //使用路径创建File对象
        //File file = new File(String pathname)
//        File file = new File("D:\\word.txt");
        File file = new File("word.txt");

        //使用父路径、子路径创建
        //File file = new File(String father, String child)
//        String fatherPath = "D:\\";
//        String childPath = "word2.txt";
//        File file2 = new File(fatherPath, childPath);

        //使用父路径对象、子路径创建
        //File file = new File(File f, String child)
//        childPath = "word3.txt";
//        File file = new File(file2.getParent(), childPath);
        if (!file.exists()) {
//            file.delete();  //删除文件
//            System.out.println("文件已删除");
        } else {
            try {
                file.createNewFile();  //创建文件
                System.out.println("文件已创建");
                String name = file.getName();  //获取文件名称
                long length = file.length();  //获取文件长度
                boolean hidden = file.isHidden(); //判断是否是隐藏文件
                System.out.println("文件名称：" + name);
                System.out.println("文件长度：" + length);
                System.out.println("是否是隐藏文件：" + hidden);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

• FileInputStream与FileOutputStream类

  • 不足：这两个类都只提供了对字节或字节数组的读取方法。由于汉字在文件中占两个字节，使用字节流，读取不好会出现乱码，此时采用字符流可避免这种现象

• FileReader与FileWriter类

  //FileInputStream与FileOutputStream类
  package IO;

  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileOutputStream;

  public class FileInputStreamFileOutputStream {
  public static void main(String[] agrs) {
  File file = new File("word.txt");

      //没有文件就创建
      if (file.exists()) {
          System.out.println("存在文件" + file.getPath());
      } else {
          try {
              file.createNewFile();
          } catch (Exception e) {
              e.printStackTrace();
          }
      }
  //写入字节流
  try {
      //创建FileOutputStream对象
      FileOutputStream outputStream = new FileOutputStream(file);
      //创建byte数组
      byte[] buy = "我有一只小毛驴，我从来也不骑。".getBytes();
      outputStream.write(buy);  //将数组中的信息写入到文件中
      outputStream.close();  //将流关闭
  } catch (Exception e) {
      e.printStackTrace();
  }
  
  //读出字节流
  try {
      //创建FileInputStream对象
      FileInputStream fileInputStream = new FileInputStream(file);
      byte[] byt = new byte[1024];  //创建数组
      int len = fileInputStream.read(byt);
      //将文件中的信息输出
      System.out.println("文件中的信息是：" + new String(byt, 0, len));
      fileInputStream.close();
  } catch (Exception e) {
      e.printStackTrace();
  }
  }

  }

flush()方法用于即使在缓存区没有满的情况下也将缓存区的内容强制写入外设，习惯上称这个过程为刷新，flush()方法只对使用缓存区的OutputStream类的子类有效，调用close()方法时，系统关闭流之前，也会将缓存区中的信息刷新到磁盘文件

• BufferedInputStream和BufferedOutputStream类

  • 可以对所有的InputStream类进行带缓存区的包装以达到性能的优化
  • 构造方法
  • BufferedInputStream(InputStream in, int size); size默认32字节
  • BufferedOutputStream(InputStream in, int size); size默认32字节

• BufferedReader和BufferedWriter类

  • 分别继承Reader类和Writer类
  • 常用方法
  • BufferedReader
    • read(); 读取单个字符
    • readLine(); 读取一个文本行，返回字符串。无数据可读返回null
  • BufferedWriter
    • write(String s, int off, int len); 写入字符串的一部分
    • flush(); 刷新流的缓存
    • newLine(); 写入一个行分隔符

  package IO;

  import java.io.*;

  public class students {
  public static void main(String[] agrs) {
  String[] contents = {"好久不见", "最近好吗", "常联系"};

      //写数据
      File file = new File("students.txt");  //创建File对象
      try {
          FileWriter fw = new FileWriter(file);  //创建FileWriter对象
          BufferedWriter bufw = new BufferedWriter(fw);
          for (int i = 0; i < contents.length; i++) {
              bufw.write(contents[i]);
              bufw.newLine();
          }
          bufw.close();
          fw.close();
      } catch (Exception e) {
          e.printStackTrace();
      }
  //读数据
  try {
      FileReader fr = new FileReader(file);  //创建FileReader对象
      BufferedReader bufw = new BufferedReader(fr);
      String s = null;  //创建字符串对象
      int i = 0;
      //如果文件的文本行数不为null则进入循环
      while ((s = bufw.readLine()) != null) {
          i++;
          System.out.println("第" + i + "行：" + s);
      }
  } catch (Exception e) {
      e.printStackTrace();
  }
  }

  }

• DataInputStream类和DataOutputStream类，允许以与机器无关的方式从底层输入流中读取基本的java数据类型

• 构造方法

  • DataInputStream(InputStream in); 从指定的基础InputStream创建一个DataInputStream
  • DataOutputStream(OutStream out); 创建一个新的数据输出流，将数据写入指定基础输出流
    • writeBytes(String s); 由于java字符是unicode编码，双字节，只写入字节的低字节内容
    • writeChars(String s); 两个字节都写入
    • writeUTF(String s); 按照utf编码后的字节长度写入

  package IO;

  import java.io.*;

  public class Example {
  public static void main(String[] args) {
  File file = new File("hi.txt");
  try {
  FileOutputStream fs = new FileOutputStream(file);
  DataOutputStream ds = new DataOutputStream(fs);
  ds.writeUTF("使用writeUTF()方法写入数据"); //使用这个写，可以读出来
  ds.writeBytes("使用writeBytes()方法写入数据");
  ds.writeChars("使用writeChars()方法写入数据");
  ds.close(); //关闭流

          FileInputStream fis = new FileInputStream(file);
          DataInputStream dis = new DataInputStream(fis);
          System.out.println(dis.readUTF());
          dis.close();
      } catch (Exception e) {
          e.printStackTrace();
      }
  
  }

  }

java的内置类提供了非常好用的相关类，java.util.zip包中的ZipOutputStream和ZipInputStream类实现文件的压缩/解压缩

• ZipOutputStream类，可将文件压缩为.zip文件

  • 构造方法ZipOutputStream(OutputStream out);

• ZipInputStream类可读取ZIP压缩格式的文件，包括已压缩和未压缩的条目entry

  • 构造方法ZipInputStream(InputStream in);

//压缩文件
package IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class MyZip {
    private void zip(String zipFileName, File inputFile) throws Exception {
        //创建ZipOutputStream对象
        ZipOutputStream out = new ZipOutputStream(new FileOutputStream(zipFileName));
        zip(out, inputFile, "");  //调用方法
        System.out.println("Ziping...");  //输出信息
        out.close();  //关闭流
    }

    private void zip(ZipOutputStream out, File f, String base) throws Exception {
        if (f.isDirectory()) {
            File[] fl = f.listFiles();
//            if (base.length() != 0) {
//                out.putNextEntry(new ZipEntry(base + "\\")); //写入此目录的entry??
//            }
            for (int i = 0; i < fl.length; i++) {
                zip(out, fl[i], base + fl[i]);
            }
        } else {
            out.putNextEntry(new ZipEntry(base));  //创建新的进入点
            FileInputStream in = new FileInputStream(f);
            int b;
            System.out.println(base);
            while ((b = in.read()) != -1) {  //如果没有达到流的尾部
                out.write(b);                 //将自己写入当前ZIP条目
            }
            in.close();
        }
    }

    public static void main(String[] args) {
        MyZip book = new MyZip();
        try {
            book.zip("D:\\zi.zip", new File("src\\number"));
            System.out.println("done.");
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}


//解压缩
package IO;

import java.io.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;

public class MyZip2 {
    public static void main(String[] args) {
        File file = new File("D:\\zi.zip");  //当前压缩文件
        try {
            ZipFile zipFile = new ZipFile(file);  //创建压缩文件对象
            ZipInputStream zin = new ZipInputStream(new FileInputStream(file)); //创建ZipInputStream对象
            ZipEntry entry = zin.getNextEntry();  //跳过根目录，获取下一个ZipEntry
            while (((entry = zin.getNextEntry()) != null)
                    && !entry.isDirectory()) {  //entry不为空，并不在同一目录下
                File tmp = new File("D:\\" + entry.getName());  //解压出的文件路径
                if (!tmp.exists()) {
                    tmp.getParentFile().mkdirs();  //创建文件父类文件夹路径
                    OutputStream os = new FileOutputStream(tmp);  //将文件目录中的文件放入输出流
                    InputStream in = zipFile.getInputStream(entry);  //用输入流读取压缩文件中制定目录中的文件
                    int count = 0;
                    while ((count = in.read()) != -1) {  //如果有输入流可以读取到数值
                        os.write(count);                 //输入流写入
                    }
                    os.close();  //关闭输出流
                    in.close();  //关闭输入流
                }
                zin.closeEntry();  //关闭当前entry
                System.out.println(entry.getName() + " unzip successfully.");
            }
            zin.close();  //关闭流

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

16 反射

java.lang.reflect

所有类都继承与Object类，在Object类中定义了一个getClass方法，该方法返回一个类型为Class的对象，利用Class类的对象可以访问的主要信息。getFields()和getMethods()方法依次获得权限为public的成员变量和方法，包含从父类继承的成员变量和方法。getDeclaredFields()和getDeclaredMethods()只获得在本类中定义的所有成员变量和方法。

访问构造方法

通过上面表中构造方法访问，返回Constructor类型的对象或数组。每个Constructor对象代表一个构造方法。利用每个Constructor对象可以操纵相应的构造方法。

package ex16_reflect;

public class Example_01 {
    String s;
    int i;
    int i2;
    int i3;

    private Example_01() {
    }

    protected Example_01(String s, int i) {
        this.s = s;
        this.i = i;
    }

    public Example_01(String... strings) throws NumberFormatException {
        if (0 < strings.length) {
            i = Integer.valueOf(strings[0]);
        }
        if (1 < strings.length) {
            i2 = Integer.valueOf(strings[1]);
        }
        if (2 < strings.length) {
            i3 = Integer.valueOf(strings[2]);
        }
    }

    public void print() {
        System.out.println("s = " + s);
        System.out.println("i = " + i);
        System.out.println("i2 = " + i2);
        System.out.println("i3 = " + i3);
    }
}
//============================================================================

package ex16_reflect;

import java.lang.reflect.Constructor;

public class Main_01 {
    public static void main(String[] args) {
        Example_01 example = new Example_01("10", "20", "30");
        Class<? extends Example_01> exampleC = example.getClass();
        Constructor[] declaredConstructors = exampleC.getDeclaredConstructors();  //获得所有构造方法
        for (int i = 0; i < declaredConstructors.length; i++) {  //遍历所有构造方法
            Constructor<?> constructor = declaredConstructors[i];
            System.out.println("查看是否允许带有可变数量的参数：" + constructor.isVarArgs());  //是否有可变参数

            System.out.println("该构造方法的入口参数类型依次为：");
            Class[] parameterTypes = constructor.getParameterTypes();  //获取所有参数类型
            for (int j = 0; j < parameterTypes.length; j++) {
                System.out.println("" + parameterTypes[j]);
            }

            System.out.println("该构造方法可能抛出的异常类型为：");
            Class[] exceptionTypes = constructor.getExceptionTypes();  //获取所有异常类型
            for (int j = 0; j < exceptionTypes.length; j++) {
                System.out.println(" " + exceptionTypes[j]);
            }

            Example_01 example2 = null;
            while (example2 == null) {
                try {
                    if (i == 2) {
                        example2 = (Example_01) constructor.newInstance();
                    } else if (i == 1) {
                        example2 = (Example_01) constructor.newInstance("7", 5);
                    } else {
                        Object[] parameters = new Object[]{new String[]{"100", "200", "300"}};
                        example2 = (Example_01) constructor.newInstance(parameters);
                    }
                } catch (Exception e) {
                    //该构造方法权限为private，默认不允许使用反射利用newInstance()创建对象，先执行setAccessible(true);则允许创建
                    System.out.println("在创建对象时抛出异常，下面执行setAccessible()方法");
                    constructor.setAccessible(true);
                }
            }
            if (example2 != null) {
                example2.print();
                System.out.println();
            }
        }
    }
}

访问成员变量

返回Field类型的对象或数组，每个Field对象代表一个成员变量，利用Filed对象可以操纵相应的成员变量。

package ex16_reflect;

public class Example_02 {
    int i;
    public float f;
    protected boolean b;
    private String s;
}

//=========================================================

package ex16_reflect;

import java.lang.reflect.Field;

public class Main_02 {
    public static void main(String[] args) {
        Example_02 example = new Example_02();
        Class exampleC = example.getClass();  //使用getClass()获得Class对象
        Field[] declaredFields = exampleC.getDeclaredFields();  //获得所有成员变量
        for (int i = 0; i < declaredFields.length; i++) {
            Field field = declaredFields[i];  //遍历成员变量
            System.out.println("名称为：" + field.getName());  //获取成员变量名称
            Class fieldType = field.getType();
            System.out.println("类型为：" + fieldType);  //获取成员变量类型

            boolean isTrue = true;
            while (isTrue) {
                //如果该成员变量的访问权限为private，则抛出异常，则不允许访问
                try {
                    isTrue = false;
                    System.out.println("修改前的值：" + field.get(example));

                    if (fieldType.equals(int.class)) {  //判断变量类型是否是int类型
                        System.out.println("利用方法setInt()修改成员变量的值");
                        field.setInt(example, 168);
                    } else if (fieldType.equals(float.class)) {  //判断变量类型是否是float类型
                        System.out.println("利用方法setFloat()修改成员变量的值");
                        field.setFloat(example, 99.9F);
                    } else if (fieldType.equals(boolean.class)) {
                        System.out.println("利用方法setBoolean()修改成员变量的值");
                        field.setBoolean(example, true);
                    } else {
                        System.out.println("利用方法set()修改成员变量的值");
                        field.set(example, "MWQ");  //可以为各种类型的成员变量赋值
                    }
                    System.out.println("修改后的值：" + field.get(example));
                } catch (Exception e) {
                    //String s;权限为private，需要先设置setAccessible()再修改
                    System.out.println("在设置成员变量时抛出异常，下面执行setAccessible()方法");
                    field.setAccessible(true);
                    isTrue = true;
                }
            }
            System.out.println("---------------------------");
        }

        Field field = declaredFields[3];
        try {
            field.set(example, "hi");
            System.out.println(field.get(example));
            field.setAccessible(false);  //修改过一次后就一直是true了
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

访问方法

通过getMethod()等方法访问方法时，返回Method()类型的对象和数组。每个Method对象代表一个方法。利用Method对象可以操纵相应的方法。

package ex16_reflect;

public class Example_03 {
    static void staticMethod() {
        System.out.println("执行staticMethod()方法");
    }

    public int publicMethod(int i) {
        System.out.println("执行publicMethod()方法");
        return i * 100;
    }

    protected int protectedMethod(String s, int i) throws NumberFormatException {
        System.out.println("执行protectedMethod()方法");
        return Integer.valueOf(s) + i;
    }

    private String privateMethod(String... strings) {
        System.out.println("执行privateMethod()方法");
        StringBuffer stringBuffer = new StringBuffer();
        for (int i = 0; i < strings.length; i++) {
            stringBuffer.append(strings[i]);
        }
        return stringBuffer.toString();

    }
}
//============================================================

package ex16_reflect;

import java.lang.reflect.Method;

public class Main_03 {
    public static void main(String[] args) {
        Example_03 example = new Example_03();
        Class exampleC = example.getClass();
        Method[] declaredMethods = exampleC.getDeclaredMethods();  //获取所有方法
        for (int i = 0; i < declaredMethods.length; i++) {
            Method method = declaredMethods[i];  //遍历方法
            System.out.println("名称为：" + method.getName());  //获取方法名称

            System.out.println("是否允许带有可变数量的参数：" + method.isVarArgs());  //是否有可变参数

            System.out.println("入口参数类型依次为：");  //入口参数类型
            Class[] parameterTypes = method.getParameterTypes();
            for (int j = 0; j < parameterTypes.length; j++) {
                System.out.println(" " + parameterTypes[j]);
            }

            System.out.println("返回值类型：" + method.getReturnType());  //返回值类型

            System.out.println("可能抛出的异常：");
            Class[] exceptionTypes = method.getExceptionTypes();  //可能抛出的异常类型
            for (int j = 0; j < exceptionTypes.length; j++) {
                System.out.println(" " + exceptionTypes[j]);
            }

            boolean isTrue = true;
            while (isTrue) {
                //如果方法访问权限为private抛出异常，不允许访问
                try {
                    isTrue = false;
                    if ("staticMethod".equals(method.getName())) {
                        method.invoke(example);  //执行没有入口参数的方法staticMethod
                    } else if ("publicMethod".equals(method.getName())) {
                        System.out.println("返回值为："
                                + method.invoke(example, 168));  //执行方法
                    } else if ("protectedMethod".equals(method.getName())) {
                        System.out.println("返回值为："
                                + method.invoke(example, "7", 5));  //执行方法
                    } else if ("privateMethod".equals(method.getName())) {
                        Object[] parameters = new Object[]{new String[]{"M", "W", "Q"}};  //定义二维数组
                        System.out.println("返回值为："
                                + method.invoke(example, parameters)); //执行方法
                    }

                } catch (Exception e) {
                    //privateMethod()权限为private需要先setAccessible(true);才可以访问
                    System.out.println("在执行方法时出现异常，执行下面的setAccessible()方法");
                    method.setAccessible(true);
                    isTrue = true;
                }
            }
            System.out.println();
        }
    }
}

定义Annotation类型

• 使用@interface，这个关键字的隐含意思是继承java.lang.annotation.Annotation接口
• 使用@Annotation，设置Annotation类型使用的成员元素种类，使用枚举类ElementType中的枚举常量设置
• 使用@Retention，设置Annotation的有效范围，使用枚举类RetentionPolicy中的枚举常量设置

package ex16_reflect;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.CONSTRUCTOR)  //用于构造方法
@Retention(RetentionPolicy.RUNTIME)  //在运行时加载Annotation到JVM中
public @interface Constructor_Annotation {
    String value() default "默认构造方法";  //定义一个具有默认值的String型成员
}

package ex16_reflect;

import java.lang.annotation.*;
//用于字段、方法、参数
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})

//在运行时加载Annotation到JVM中
@Retention(RetentionPolicy.RUNTIME)

public @interface Field_Method_Parameter_Annotation {
    String describle();               //定义一个没有默认值的String型成员
    Class type() default void.class;  //定义一个具有默认值的Class型成员
}

访问Annotation信息

在定义Annotation类型时，@Retention设置为RetentionPolicy.RUNTIME，那么在程序运行时通过反射就可以获取到相关的Annotation信息，如获取构造方法、字段、方法的Annotation信息。

• Constructor、Field、Method均继承了AccessableObject类，在AccessibleObject中定义了3个关于Annotation的方法

  • isAnnotationPresent(Class annotationClass); 查看是否添加了指定类型的Annotation
  • getAnnotation(Class annotationClass); 获得指定类型的Annotation，存在返回相应对象，不存在返回null
  • getAnnotations(); 返回所有Annotation，返回一个数组

• 在Constructor和Method中还定义了方法getParameterAnnotations(); 用来获得所有参数添加的Annotation，将以Annotation类型的二维数组返回，在数组中的顺序与声明顺序相同，没有参数则返回长度为0的数组；未添加Annotation参数用长度为0的嵌套数组占位

在Record类中运用前面定义的Annotation类型@Constructor_Annotation和@Field_Method_Parameter_Annotation.

package ex16_reflect;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Record {
    @Field_Method_Parameter_Annotation(describle = "编号", type = int.class)
    int id;
    @Field_Method_Parameter_Annotation(describle = "姓名", type = String.class)
    String name;

    @Constructor_Annotation()
    public Record() {
    }

    @Constructor_Annotation("立即初始化构造方法")
    public Record(
            @Field_Method_Parameter_Annotation(describle = "编号", type = int.class) int id,
            @Field_Method_Parameter_Annotation(describle = "姓名", type = String.class) String name) {
        this.id = id;
        this.name = name;
    }

    @Field_Method_Parameter_Annotation(describle = "获得编号", type = int.class)
    public int getId() {
        return id;
    }

    @Field_Method_Parameter_Annotation(describle = "设置编号")
    public void setId(
            @Field_Method_Parameter_Annotation(describle = "编号", type = int.class) int id) {
        this.id = id;
    }

    @Field_Method_Parameter_Annotation(describle = "获得姓名", type = String.class)
    public String getName() {
        return name;
    }

    @Field_Method_Parameter_Annotation(describle = "设置姓名")
    public void setName(
            @Field_Method_Parameter_Annotation(describle = "姓名", type = String.class) String name) {
        this.name = name;
    }

    public static void main(String[] args) {
        Record record = new Record();
        Class recordC = record.getClass();

        //========================访问构造方法(Constructor)====================================
        System.out.println("=====访问构造方法(Constructor)=======");
        Constructor[] declaredConstructors = recordC.getDeclaredConstructors();  //获得所有构造方法
        for (int i = 0; i < declaredConstructors.length; i++) {  //遍历构造方法
            Constructor constructor = declaredConstructors[i];
            //判断是否是指定类型的注释
            if (constructor.isAnnotationPresent(Constructor_Annotation.class)) {
                //获取指定类型的注释
                Constructor_Annotation ca = (Constructor_Annotation) constructor
                        .getAnnotation(Constructor_Annotation.class);
                System.out.println(ca.value());   //获得注释信息
            }
            //获得参数的注释
            Annotation[][] parameterAnnotations = constructor.getParameterAnnotations();
            for (int j = 0; j < parameterAnnotations.length; j++) {
                //获得指定参数注释的长度
                int length = parameterAnnotations[j].length;
                if (length == 0) {  //长度为0表示没有为该参数添加注释
                    System.out.println("未添加Annotation的参数");
                } else {
                    for (int k = 0; k < length; k++) {
                        //获得参数的注释
                        Field_Method_Parameter_Annotation pa =
                                (Field_Method_Parameter_Annotation) parameterAnnotations[j][k];
                        System.out.println("  " + pa.describle());  //获得参数描述
                        System.out.println("  " + pa.type());       //获得参数类型
                    }
                }
            }
            System.out.println();
        }

        //============================访问字段(Field)=====================================
        System.out.println("=======访问字段(Field)==========");
        Field[] declaredFileds = recordC.getDeclaredFields();  //获得所有字段
        for (int i = 0; i < declaredFileds.length; i++) {
            Field field = declaredFileds[i];
            //查看是否具有指定类型的注释
            if (field.isAnnotationPresent(Field_Method_Parameter_Annotation.class)) {
                //获得指定类型的注释
                Field_Method_Parameter_Annotation fa = field
                        .getAnnotation(Field_Method_Parameter_Annotation.class);
                System.out.println("  " + fa.describle());  //获得字段的描述
                System.out.println("  " + fa.type());       //获得字段的类型
            }
            System.out.println();
        }

        //============================访问方法(Method)及包含参数的Annotation信息================
        System.out.println("===访问方法(Method)及包含参数的Annotation信息===");
        Method[] methods = recordC.getDeclaredMethods();  //获得所有方法
        for (int i = 0; i < methods.length; i++) {
            Method method = methods[i];
            //查看是否有指定类型的注释
            if (method.isAnnotationPresent(Field_Method_Parameter_Annotation.class)) {
                //获得指定类型的注释
                Field_Method_Parameter_Annotation ma = method
                        .getAnnotation(Field_Method_Parameter_Annotation.class);
                System.out.println("  " + ma.describle());  //获得方法的描述
                System.out.println("  " + ma.type());       //获得方法的返回值类型
            }
            //获得参数的注释
            Annotation[][] parameterAnnotations = method
                    .getParameterAnnotations();
            for (int j = 0; j < parameterAnnotations.length; j++) {
                int length = parameterAnnotations[j].length;
                if (length == 0) {
                    System.out.println("未添加Annotation的参数");
                } else {
                    for (int k = 0; k < length; k++) {
                        //获得指定类型的注释
                        Field_Method_Parameter_Annotation pa =
                                (Field_Method_Parameter_Annotation) parameterAnnotations[j][k];
                        System.out.println("  " + pa.describle());  //获得参数描述
                        System.out.println("  " + pa.type());       //获得参数类型
                    }
                }
            }
            System.out.println();
        }
    }
}

17 枚举类型与泛型

• 使用接口设置常量
• 枚举类型，相当于一个类，继承于java.lang.Enum，每一个枚举类型成员是一个实例，默认被public、static、final修饰，使用时直接使用枚举类型名称调用
  • 枚举类型常用方法
  • 枚举类型中的构造方法
  • 可以在每个枚举成员内部实现接口中的方法（每个成员都要实现）

//枚举类型的定义与使用
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; MultiOverClass x = new MultiOverClass<>();
  • 定义泛型类时声明数组类型 private T[] array;
  • 集合类声明容器的元素
    • Map: HashMap, TreeMap
    • Set: HashSet, TreeSet
    • List: ArrayList, TreeList

• 泛型的高级用法

  • 限制泛型可用类型 没有使用限制时，默认Object类下的所有子类都可以实例化泛型对象

    • class 类名称 anyClass是任何接口或类
    • 泛型类的类型必须实现或继承了anyClass这个接口或类，使用关键字extends

  • 使用通配符

    • 主要作用是在创建一个泛型类对象时限制这个泛型类对象的类型实现或继承某个接口或类的子类
    • 泛型类名称 a = null; 泛型类对象a只能被赋值对象为实现List的子类或接口
    • List list 定义的泛型类对象只能获取或删除元素，不能添加新信息（因为是？编译器不知道添加什么信息）

  • 泛型的向上限制

    • 使用super关键字
    • A a = null; 表示对象a只接受List接口或上层父类类型

  • 定义为泛型的类和接口也可以被继承和实现

    • 如果没有在继承时指明泛型的继承，在子类中都会默认为Object类型

总结：

• 泛型的类型参数只能是类类型，不可以是简单类型
• 泛型的类型参数可以是多个
• 可以使用extends super关键字限制泛型的类型
• 可以使用通配符限制泛型的类型

//泛型的定义
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);
        }
    }
}

18 多线程

每一个程序都是一个进程，一个进程可以有多个线程，线程是进程的一个执行流程

• 继承java.lang.Thread类

• 实现java.lang.Runnable接口 （java不支持多继承，在需要继承其他类又需要实现多线程利用接口实现）

• 线程的生命周期：出生状态、就绪状态、运行状态、等待状态、休眠状态、阻塞状态、死亡状态

• 线程的休眠 Thread.sleep()，sleep为Thread的静态方法，单位毫秒

• 线程的加入 thread.join()，在线程A中加入线程B，执行完B后在执行A

• 线程的中断 thread.interrupt()，引发InterruptedException，通常在catch中关闭数据库连接和socket连接等操作。提倡run中使用无线循环的方式，然后使用一个布尔型标记控制循环的停止。

• 线程的礼让 yield()，对于多任务操作系统不需要使用，操作系统会自动分配CPU时间片

系统始终选择就绪状态下优先级较高的线程进入运行状态。优先级高的并不一定先执行，也取决于操作系统

多线程资源同步的问题都是采用给定时间只允许一个线程访问共享资源，给资源上一把锁

• 同步块synchronized()，将对资源的操作放在同步块中

• 同步方法，在方法前加synchronized修饰，某个对象调用同步方法时必须等该同步方法执行完毕后才被执行

  //继承Thread
  package ex18_Thread;

  public class ThreadTest extends Thread {
  private int count = 10;
  public void run() { // 覆盖run()方法
  while (true) {
  System.out.print(count + " ");
  if (--count == 0)
  return;
  }
  }

  public static void main(String args[]) {
      ThreadTest t1 = new ThreadTest();
      ThreadTest t2 = new ThreadTest();
      t1.start();  // 线程执行调用start()
      t2.start();
  }

  }

  //使用Runnable接口实现多线程
  package ex18_Thread;

  import javax.swing.; import java.awt.;
  import java.net.URL;
  import java.util.EmptyStackException;

  public class SwingAndThread extends JFrame {
  private JLabel jl = new JLabel(); // 声明JLable对象
  private static Thread t; //声明线程对象
  private int count = 0; //声明计数变量
  private Container container = getContentPane(); //声明容器

  public SwingAndThread() {
      setBounds(100,100,1000,1000);  //绝对定位窗体大小和位置
      container.setLayout(null);  //不使用任何布局管理器
      URL url = SwingAndThread.class.getResource("/ex18_Thread/1.gif");  //获取图标url
      Icon icon = new ImageIcon(url);  //实例化一个icon
      jl.setIcon(icon);  //将图标放在标签中
      jl.setHorizontalAlignment(SwingConstants.LEFT); //将图片放在左边

  // jl.setBounds(10,10,500,500); //设置标签位置和大小
  jl.setOpaque(true); //设置不透明

      t = new Thread(new Runnable() {  //定义匿名内部类，该类实现Runnable接口
          @Override
          public void run() {  //重写run()
              while (count <= 500) {
                  jl.setBounds(count,10,500,500);
                  try {
                      Thread.sleep(1000);  //线程休眠1000毫秒
                  } catch (Exception e) {
                      e.printStackTrace();
                  }
                  count += 4;
                  if (count == 500) {  //当其回到最右边时回到最左边
                      count = 10;
                  }
              }
      }
  });
  t.start();  //启用一个新线程start(), start()运行run()方法
  container.add(jl);
  setVisible(true);
  setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
  }
  public static void main(String args[]) {
      new SwingAndThread();
  }

  }

  //线程的休眠
  package ex18_Thread;

  import javax.swing.; import java.awt.;
  import java.util.Random;

  public class SleepMethodTest extends JFrame {
  private Thread t;
  private static Color[] color = {Color.BLACK, Color.BLUE,Color.CYAN,Color.RED};
  private static final Random rand = new Random(); //创建随机对象
  private static Color getC() {
  return color[rand.nextInt(color.length)];
  }

  public SleepMethodTest() {
      t = new Thread(new Runnable() {
          int x = 100;
          int y = 100;
          @Override
          public void run() {
              while (true) {
                  try {
                      Thread.sleep(100);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
                  //获取组件绘图上下文对象
                  Graphics graphics = getGraphics();
                  graphics.setColor(getC());  //设置绘图颜色
                  graphics.drawLine(x, y+=10, 800, y);
                  if (y >= 800) {
                      y = 100;
                  }
              }
          }
      });
      t.start();
  }
  
  public static void main(String args[]) {
      init(new SleepMethodTest(),1000,1000);
  }
  
  //设置窗体的各种属性的方法
  public static void init(JFrame frame, int width, int height) {
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.setSize(width, height);
      frame.setVisible(true);
  }

  }

  //线程的加入
  package ex18_Thread;

  import javax.swing.; import java.awt.;

  public class JoinTest extends JFrame {
  private Thread threadA;
  private Thread threadB;
  final JProgressBar jProgressBar = new JProgressBar();
  final JProgressBar jProgressBar1 = new JProgressBar();
  int count = 0;
  public JoinTest() {
  super();
  getContentPane().add(jProgressBar, BorderLayout.NORTH);
  getContentPane().add(jProgressBar1, BorderLayout.SOUTH);
  jProgressBar.setStringPainted(true);
  jProgressBar1.setStringPainted(true);
  //使用匿名内部类初始化Thread实例
  threadA = new Thread(new Runnable() {
  int count = 0;
  @Override
  public void run() {
  while (true) {
  jProgressBar.setValue(count++);
  try {
  Thread.sleep(100);
  threadB.join();
  } catch (Exception e) {
  e.printStackTrace();
  }
  }
  }
  });
  threadA.start();

      threadB = new Thread(new Runnable() {
          int count = 0;
          @Override
          public void run() {
              while (true) {
                  jProgressBar1.setValue(count++);
                  try {
                      Thread.sleep(100);
                  } catch (Exception e) {
                      e.printStackTrace();
                  }
                  if (count + 1 == 100)
                      break;
              }
          }
      });
      threadB.start();
  
  }
  
  public static void main(String args[]) {
      init(new JoinTest(), 100,100);
  }
  
  //设置窗体的各种属性的方法
  public static void init(JFrame frame, int width, int height) {
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.setSize(width, height);
      frame.setVisible(true);
  }

  }

  //线程的中断
  package ex18_Thread;

  import javax.swing.; import java.awt.;

  public class InterruptedSwing extends JFrame {
  Thread thread;

  public InterruptedSwing() {
      super();
      final JProgressBar progressBar = new JProgressBar();
      getContentPane().add(progressBar, BorderLayout.NORTH);
      progressBar.setStringPainted(true);
      thread = new Thread(new Runnable() {
          int count = 0;
          @Override
          public void run() {
              while (true) {
                  progressBar.setValue(count++);
                  try {
                      thread.sleep(1000);
                  } catch (InterruptedException e) {
                      System.out.println("当前程序被中断");
                      break;
                  }
              }
      }
  });
  thread.start();
  thread.interrupt();
  }
  
  public static void main(String[] args) {
      init(new InterruptedSwing(), 100, 100);
  }
  
  //设置窗体的各种属性的方法
  public static void init(JFrame frame, int width, int height) {
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.setSize(width, height);
      frame.setVisible(true);
  }

  }

19 网络通信

• TCP/IP协议中有两种协议：TCP、UDP
• 端口和套接字
  • 端口：0-65535，通过不同的端口连接不同的服务，HTTP80，FTP21，
  • 套接字： 用来连接应用程序与端口，类似于插座连接电线与电器

java.net.InetAdress类，与IP地址相关的类，InetAdress类的方法会抛出UnknownHostException，所以必须进行异常处理

java.net.ServerSocket类用于表示服务器套接字

java.net.DatagramPacket类表示数据包，java.net.DatagramSocket类表示发送和接受数据包的套接字

package ex19_Net;

import java.net.InetAddress;
import java.net.UnknownHostException;

public class InetAdress_test {
    public static void main(String args[]) {
        InetAddress ip;
        try {
            ip = InetAddress.getLocalHost();
            String localname = ip.getHostName();
            String localip = ip.getHostAddress();
            System.out.println("name: " + localname);
            System.out.println("ip: " + localip);

        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }

}


package ex19_Net;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class TCP_test {
    private BufferedReader reader;
    private ServerSocket server;
    private Socket socket;
    void getserver() {
        try {
            server = new ServerSocket(8998);
            System.out.println("服务器套接字创建成功");
            while (true) {
                System.out.println("等待客户机的连接");
                socket = server.accept();
                reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                getClientMessage();
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void getClientMessage() {
        try {
            while (true) {
                System.out.println("客户机：" + reader.readLine());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            if (reader != null) {
                reader.close();
            }
            if (socket != null) {
                socket.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String args[]) {
        TCP_test tcp = new TCP_test();
        tcp.getserver();
    }

}


package ex19_Net;

import javax.swing.*;
import javax.swing.border.BevelBorder;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.PrintWriter;
import java.net.Socket;

public class TCP_test_client extends JFrame {
    private PrintWriter writer;
    Socket socket;
    private JTextArea ta = new JTextArea();
    private JTextField tf = new JTextField();
    Container cc;
    public TCP_test_client(String title) {
        super(title);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        cc = this.getContentPane();
        final JScrollPane scrollPane = new JScrollPane();
        scrollPane.setBorder(new BevelBorder(BevelBorder.RAISED));
        getContentPane().add(scrollPane, BorderLayout.CENTER);
        scrollPane.setViewportView(ta);
        cc.add(tf,"South");
        tf.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                writer.println(tf.getText());
                ta.append(tf.getText() + '\n');
                ta.setSelectionEnd(ta.getText().length());
                tf.setText("");
            }
        });
    }

    private void connect() {
        ta.append("尝试连接\n");
        try {
            socket = new Socket("127.0.0.1",8998);
            writer = new PrintWriter(socket.getOutputStream(),true);
            ta.append("完成连接\n");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String args[]) {
        TCP_test_client client = new TCP_test_client("向服务器发生数据");
        client.setSize(200,200);
        client.setVisible(true);
        client.connect();
    }
}

20 数据库操作

• Connection接口

• Statement接口

• PreparedStatement接口

• DriveManage类

• ResultSet接口

• 连接数据库

• 向数据库发送SQL语句

• 处理查询结果集

• 顺序查询

• 模糊查询

• 预处理语句

• 添加修改删除记录