Java语言基础#

数据类型#

• 标识符规则

  • 由字母、 数字、下划线、 $组成。不能由数字开头。
  • 不能含有其他任何字符（包括空格）
  • 不能是Java中的保留字(关键字)。
  • 大小写敏感，长度无限制。

• 变量类型

  • 8种基本数据类型（byte1, short2, int4, long8, float4, double8, char2, boolean）
  • 构造数据类型（类）

• 常量类型

  • 数值常量
  • 符号常量：final int a = 10;，值一旦确定不可更改，类静态成员常量只能在定义时初始化
  • 注意事项
    • 一个整型常量在机器中默认以int类型存储
    • 一个实型常量在机器中默认以double类型存储
    • 十进制表示法小数点的两侧都必须有数字
    • 科学表示法尾数必须有，但小数部分可无，阶码必须是整数
    • 不可将布尔类型看做整型值。

运算符及表达式#

• 自增自减

  • 只能用于变量，而不能用于常量或表达式
  • a = 5; a--+10; 表达式的值为15，a变为4

• 除法

  • 整数相除，截尾法取整
  • 浮点数相除，是通常意义的除法

• 除余

  1
  5%2=1
  2
  5.2%2=1.2
  3
  5.2%2.2=0.8
  4
  10%-4=2
  5
  -10%-4=-2

• 如果整数相除或取模，第二个操作数为0，编译无错，运行会出错。如果浮点数相除，第二个操作数为0，结果为Infinity，0.0/0除外是NaN。如果浮点数取模，第二个操作数为0，结果为NaN

• 字符串连接

  1
  //A的ASCII码是65，a的ASCII码是97(65+32)
  2
  'a'+1        //98
  3
  'A'+2+2.5    //69.5
  4
  ""+'a'+1     //a1
  5
  "abc"+1+2.3  //abc12.2
  6
  1+2.3+"abc"  //3.3abc
  7
  1+"abc" +2.3 //1abc2.3

• 对象运算符用来确定一对象是否是某一指定类的对象

  1
  Test t1 = new Test();
  2
  if(t1 instanceof Test) System.out.println("Yes");

• 逻辑运算符，&和|没有短路逻辑，&&和||有

• 移位之前先把移的位数与被移位的位数求余数，然后移动这个位数

• 优先级

• 一个实型常量在机器中默认以double类型存储。实型常量后加后缀F或f在机器中以float类型存储。

• 数据类型转换

  • 自动转换，自动把精度较低的类型转换为另一种精度较高的类型，如果byte、short、char在一起运算时，会先将这些值转换为int型。再进行运算，结果为int型。

  • 手动强制转换

    • 强制类型转换可能造成信息的丢失
    • 布尔型与其它基本类型之间不能转换

    1
    int i; byte b,c;
    2
    b=(byte)345;      //上机测试知b得到89(345%256)
    3
    c=(byte)356;      //上机测试知c得到100(356%256)
    4
    i=(int)(3.8+6);   //截尾法

    • TIPS
      • 在运算过程中，运算的结果至少是int型，即如果参与运算的两个数级别比int型低或是int型，则结果为int型
      • 参与运算的数据如果有一个级别比int型高，则运算结果的类型与类型级别高的数相同
      • 参与运算的两个数据如果类型不一样，会先把低级的数据转换成高级的类型的数据后再作运算，结果是高级的类型

  • 隐含强制转换

    • 把int类型的常量赋给byte、short变量时不需要强制类型转换
    • 把int类型的变量赋给byte、short类型的变量时必须强制转换，否则会出错

    1
    float x=3.3f;
    2
    double y=2.9;
    3
    byte a=5;
    4
    x+(int)y/3*a;    //float

语句#

• 标准输入输出

  • System.out

    1
    System.out.println();
    2
    System.out.print();

    • System.in读一个字节，需要捕获异常IOException
    • int read()从流中读取一个字节并将该字节作为整数返回,若没有数据则返回-1
    • int read(byte b[]) 从流中读取多个字节放到b中, 返回实际读取到的字节数
    • int read(byte b[],int off,int len) 从流中读取最多len字节的数据, 放到数组b的下标off开始的单元中，返回读取到的字节数

    1
    import java.io.*;
    2
    public class ReadChar {
    3
       public static void main(String args[]) {
    4
        try {
    5
          char ch=(char)System.in.read();
    6
                System.out.println(ch);
    7
            } catch(IOException e) {
    8
          e.printStackTrace();
    9
        }
    10
       }
    11
    }
    12
    
    13
    //ReadString.java
    14
    import java.io.*;
    15
    public class ReadString {
    16
        public static void main(String args[]) {
    17
            char c;
    18
            try {
    19
                do {
    20
                    c = (char)System.in.read();
    21
                    System.out.print(c);
    22
                } while(c!='\n');
    23
            } catch(IOException e) {
    24
                e.printStackTrace();
    25
            }
    26
        }
    27
    }
    28
    
    29
    //ReadStringOrInt.java
    30
    import java.io.*;
    31
    class ReadStringOrInt {
    32
      public static void main(String args[]) {
    33
        byte buf[]=new byte[20];
    34
        String str;
    35
            int anInt;
    36
          try {
    37
          System.in.read(buf);
    38
          str=new String(buf);
    39
          anInt=Integer
    40
                    .parseInt(str.trim());
    41
                //trim必须
    42
            } catch(Exception e) {
    43
                e.printStackTrace();
    44
        }
    45
      }
    46
    }

    Show moreShow less

• Scanner

  1
  Scanner sc = new Scanner(System.in);
  2
  i = sc.nextInt();
  3
  i = sc.next();

• 选择、循环、跳转等语句没啥说的跟其他语言差不多

  • for

  1
  //一种特殊的for循环
  2
  int[] scores = {89, 72, 64, 58, 93};
  3
  for ( int sco: scores ) {
  4
      System.out.println(sco);
  5
  }

  • switch

    注意break

数组#

• 声明\创建数组空间\初始化

  1
  int[] list1; list1 = new int[3];
  2
  int[] list2 = new int[3];
  3
  int[] a = {1,2,3,4};
  4
  int[] b = new int[3]; b[0]=8; b[1]=9;
  5
  int[] c; c = new int[]{1, 2, 3, 4};
  6
  int[] d = new int[]{1, 2, 3, 4};
  7
  //WRONG
  8
  //int[] a; a = {1,2,3,4};
  9
  //int a[5];
  10
  
  11
  int[][] a; a = new int[2][3];
  12
  int[][] b; b = new int[2][];
  13
  int[][] c = new int[2][3];
  14
  int[][] d ={{2,3},{1,5},{3,4}};
  15
  int[][] e = new int[][]{{2,3},{1,5},{3,4}};
  16
  
  17
  int[][] f = new int[2][];
  18
  f[0]=new int[3];
  19
  f[1]=new int[5]; //不规则数组

  Show moreShow less

  ps: 如果括号写在后面会提示是C样式的定义，建议统一写在前面，但是写在前面还是写在后面都是没有影响的

面向对象程序设计#

类的定义#

1
//类首说明
2
[修饰符] class 类名 [extends] [implements]
3
{
4
    //类体
5
  [成员变量说明]
6
  [构造方法说明]
7
  [静态初始化说明]
8
  [成员方法说明]
9
}；

类首说明#

• 修饰符
  • 访问权限修饰符缺省/public
  • 抽象类abstract
  • 最终类final
• extendsJava中一个类最多能继承一个类（单继承）
• implements接口名可以有多个

成员变量#

• 访问权限修饰符public>protected>缺省>private

tips

• 具有继承关系的子类可以继承父类的一些成员变量，即可以不创建对象就可以直接访问。如果是同一个包的子类可以继承到缺省/public/protected修饰的变量，如果是不同的包的子类就只能继承到public/protected的；

• 如果是其他类，不管是一个包还是不在一个包，都要创建该类的对象才能引用

• 如果是main方法，不管是本类还是非本类，要访问实例变量都要创建对象，可以引申到其他所有的类方法中

• 私有成员只能在本类中访问，如果在main方法中访问私有成员，必须创建对象

• 如果是创建对象，不同包的子类中定义的父类的对象只能调用public，不同包的子类中定义的子类的对象可以调用public、protected

• static

  static修饰的成员变量称为类变量（静态变量）；不用static修饰的成员变量又叫对象变量（实例变量）。可以通过类来访问静态成员变量，也可以通过该类的对象访问静态成员变量。

• final

  无论是实例变量，还是类变量，都可以被说明成常量。final修饰符和static修饰符并不冲突

  • 类常量，一定要在定义时就给定初始值，声明赋值不分开
  • 对象常量，一个final成员变量，没有static修饰，不同的对象可以有不同的值。一定要给初始值，但可有两种方法：（1）在定义变量时赋初始值（声明赋值可分开）（2）在每一个构造函数中进行赋值

• transient和volatile

• 成员变量的使用

  • 类内部：只用变量名即可访问（类内的静态方法例如main访问对象变量例外）
  • 类外部：对象变量要构造对象、类变量2种都行（static）

成员方法#

• 成员方法首部声明

  [方法修饰] 返回类型 方法名（[形参]）[throws异常]

  • 访问修饰符： 缺省/public/protected/private
  • 非访问修饰符：static/abstract/final/native/synchronized

• 成员方法调用

  • 内部调用：直接
  • 外部调用：类方法（static）、对象方法
    • 在类方法中不能直接引用对象变量。在类方法（static）中不能使用super、this关键字。类方法不能直接调用类中的对象方法。
    • 对象方法可以引用对象变量，也可以引用类变量。对象方法中可以使用supper、this关键字。对象方法中可以调用类方法。

• 方法的重载

  • 或者参数个数不同，或者参数类型不同，或者参数类型顺序不同

构造方法、对象创建#

• 对象成员变量初始化

  1. 自动初始化
  2. 通过一个成员方法显示地初始化为其他值
  3. 定义构造方法时初始化

• 构造方法

  [修饰符] 方法名（[形参]）[throws异常] {方法体}

  • 编译器内部机理
    1. 为对象分配内存空间(堆)；
    2. 按缺省值初始化对象中的实例变量的值；
    3. 调用对象的构造方法(可以在构造方法中初始化其他的值)。
  • 构造方法重载

• 对象创建

  • 对象的声名
  • 对象的实例化
  • 对象的初始化

  ps：对象是引用型变量，new以类为模板，开辟空间并执行相应的构造方法，完成对象的实例化和初始化，并返回该对象的一个引用（即该对象所在的内存首地址)

• 对象的成员变量及方法的访问

• this

  • 在方法及构造方法中，可以使用this来访问对象的属性和方法。构造方法中，用this调用另一构造方法。
  • 通过this不仅可以引用该类中定义的变量和方法，还可以引用该类的父类中定义的成员变量和方法。
  • 在所有的非static方法中，都隐含了一个参数this。而static方法中，不能使用this。

继承#

class 新的子类名 extends 继承的父类名(必须有且只能一个)

• Object类是Java中所有类的直接父类或间接父类。

• 子类特性：子类拥有其父类的所有属性和方法。但父类中说明为private的属性和方法，子类不可直接访问。子类可以对父类的方法覆盖或重载。

• 属性的继承、隐藏和添加

  • 子类可以继承父类的所有属性（只要该属性没有private修饰）
  • 子类重新定义一个与父类那里继承来的成员变量完全相同的变量，就称作属性的隐藏。
  • 在定义子类时，加上的新的属性变量，就可以使子类比父类多一些属性

• 方法的继承、覆盖、重载和添加

  • 父类的非私有方法也可以被子类自动继承

  • 覆盖：在子类中定义的方法和父类中的方法的首部是一样的，包括方法名、参数列表、返回类型和异常抛出。但方法体的实现改变了。

    ps：覆盖的方法的首部必须要和被覆盖的方法的首部完全匹配、返回值类型一致，才能达到覆盖的效果。覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

  • 重载：方法名相同，但参数列表不同（实际是相当于在子类中新加了一个方法）

    ps：在使用重载时只能通过不同的参数表样式。不能通过访问权限、返回类型、抛出的异常进行重载。被重载的方法不能为private，否则在其子类中只是新定义了一个方法。

  • 添加

  • ps：在继承机制中，不允许在子类中降低成员(包括变量和方法)的访问权限（访问权限大小关系是private<缺省<protected<public）。即如果一个方法在父类中是protected的，那么在子类中要重载或覆盖该方法时，就不能把该方法改成是缺省或private，否则会出现编译错误。

• 向上转型和向下转型

  • 向上转型

    • 用父类的引用变量去引用子类的实例，这是允许的。当向上转型之后，父类引用变量可以访问子类中属于父类的属性和方法，但是不能访问子类独有的属性和方法。

    • 向上转型，在运行时，会遗忘子类对象中与父类对象中不同的方法。也会覆盖与父类中相同的方法（重写）。

    • 向上转型之后的方法调用问题

      1
      class A {
      2
          public String Show(D obj) { return ("(A-D)"); }
      3
          public String Show(A obj) { return ("(A-A)"); }
      4
      }
      5
      class B extends A {
      6
          public String Show(B obj) { return ("(B-B)"); }
      7
          public String Show(A obj) { return ("(B-A)"); }
      8
      }
      9
      class C extends B {
      10
          public String Show(B obj) { return ("(C-B)"); }
      11
      }
      12
      class D extends B {
      13
          public String Show(D obj) { return ("(D-D)"); }
      14
          public String Show(B obj) { return ("(D-B)"); }
      15
      }
      16
      
      17
      public class mainTest {
      18
          public static void main(String args[]){
      19
             A a1 = new A();
      20
             A a2 = new B();
      21
             B b = new B();
      22
             C c = new C();
      23
             D d = new D();
      24
             System.out.println(a1.Show(b)); //(A-A)
      25
             System.out.println(a1.Show(c)); //(A-A)
      26
             System.out.println(a1.Show(d)); //(A-D)
      27
             System.out.println(a2.Show(b)); //(B-A)
      28
             System.out.println(a2.Show(c)); //(B-A)
      29
             System.out.println(a2.Show(d)); //(A-D)
      30
             System.out.println(b.Show(b));  //(B-B)
      31
             System.out.println(b.Show(c));  //(B-B)
      32
             System.out.println(b.Show(d));  //(A-D)
      33
          }
      34
      }
      35
      
      36
      //先改写类方法，再直接判断

      Show moreShow less

  • 向下转型

    • 并不是所有的对象都可以向下转型，只有当这个对象原本就是子类对象通过向上转型得到的时候才能够成功转型

• super

  • 使用情况：子类隐藏了超类中的变量或方法，而在程序中又要使用超类中被隐藏的变量或方法时使用。或者在子类的构造方法中引用超类的构造方法时使用。

  • 构造方法是不能继承的，因为继承意味着与父类的构造方法同名，但显然子类的构造方法不可能与父类的构造方法同名。但是子类的构造方法一定会调用父类的构造方法，以此类推，将继承阶层串联起来，使每个父类的构造方法皆被调用。（构造方法不能继承并不意味着子类不能调用父类的构造方法，且可以显式调用，放在第一句）

  • 注意事项

    • 通过super不仅可以访问直接父类中定义的属性和方法，还可以访问间接父类中定义的属性和方法。
    • 由于它指的是父类对象，所以super不能在static环境中使用，包括类变量、类方法和static语句块。
    • 使用super不能访问本类定义的属性和方法
    • 在构造方法中使用super时，super语句必须放在第一句
    • 在子类的构造方法中，super可以不明确使用，也可以明确使用。
    • 建议：在写多个继承关系的类时，尽量在子类的构造方法中明确使用super调用父类的构造方法，继承默认调用super（）

  • 构造方法的调用顺序

    • 首先调用父类的构造方法。这个步骤会反复递归，使继承阶层的根源最先被构建，然后是次一层的子类，直至最末一层子类为止；
    • 根据各个成员的声明顺序，执行成员变量的初始化赋值；
    • 执行该构造方法中的各语句。

    1
    class Base {
    2
        private String name = "base";
    3
        public Base() {
    4
            System.out.println("Base(): " + name);
    5
            tellName();
    6
        }
    7
        public void tellName() {
    8
            System.out.println("Base tell name: " + name);
    9
        }
    10
    }
    11
    public class Derived extends Base {
    12
        private String name = "derived";
    13
        public Derived() {
    14
            System.out.println("Derived():"+ name);
    15
            tellName();
    16
        }
    17
        public void tellName() {
    18
            System.out.println("Derived tell name: " + name);
    19
        }
    20
        public static void main(String[] args){
    21
            new Derived();
    22
        }
    23
    }
    24
    
    25
    /*输出
    26
    Base(): base
    27
    Derived tell name: null
    28
    Derived():derived
    29
    Derived tell name: derived
    30
    */

    Show moreShow less

• 父类对象与子类对象的转换

  • 原则
    • 子类对象转为父类对象时，可以是显示的或隐式的，子类对象直接向父类对象赋值；
    • 父类对象不能被任意的转换成某一子类的对象，只有父类对象指向的实际是一个子类对象，那么这个父类对象可以转换成子类对象，但此时必须用强制类型转换。
    • 如果一个方法的形式参数定义的是父类对象，那么调用这个方法时，可以使用子类对象作为实际参数。

• 抽象类与抽象方法

  • 抽象类不能创建任何对象，抽象类必须产生其子类，由子类创建对象。
  • 抽象类中可以包含抽象方法，也可以不包含抽象方法，但如果类中的某一方法是抽象的，整个类就必须被说明成抽象的。
  • 抽象方法在子类中必须被实现，否则子类仍是抽象的。
  • 抽象类不是可有可无的

• final类和final方法

  • 如果一个类被final修饰符所修饰和限定，说明这个类不能被继承，即不可能有子类，就不能重载或覆盖它的任何方法
  • 所有已被private修饰符限定为私有的方法，以及所有包含在final类中的方法，都被默认为是final的。因为这些方法不可能被子类所继承，所以不可能被重载，自然都是最终的方法。

接口#

[修饰符] interface 接口名 [extends] [接口列表] {接口体}

• 接口定义了一些没有实现的方法和静态常量集，使程序设计和实现相互分离，同时弥补Java只支持单重继承的不足，也可以约束实现接口的类。

• Java接口反映了对象较高层次的抽象，为描述相互似乎没有关系的对象的共性提供了一种有效的手段。

• 和类的区别

  • 类只能单继承，而接口可以多继承。
  • 类中的方法可以是具体的，也可以抽象的。 接口中的方法都是抽象的。
  • 接口中的方法要用类来实现，一个类可以实现多个接口。

• 和抽象类的区别

  • 接口要被子类实现，抽象类要被子类继承
  • 接口中变量全为公共静态常量，抽象类中可以有普通变量
  • 接口中都是方法的声明，抽象类中可以有方法的实现
  • 接口不可以有构造函数，抽象类可以有
  • 接口可以多实现，抽象类必须单继承
  • 接口方法都是抽象方法，抽象类可以有非抽象方法
  • 接口优先于抽象类

• 首部修饰符：不使用修饰符（同包访问），或者public（任意访问）

• 接口体：接口的成员：成员变量和方法

  • 成员变量：隐含public、static、final的静态最终变量（常量）
  • 方法：隐含public和abstract的抽象方法（不能使用static、native、synchronized、final）

• 对接口的引用

• 使用接口实现多重继承

• 多态性建立的基础

  • 继承
  • 向上转型
  • 动态绑定：能在运行期间判断参数的实际类型，并分别调用适当的方法体，从而实现了多态性。在Java中所有非final和非static的方法都会自动地进行动态绑定。

• 简单工厂模式（静态工厂方法模式）

  • 角色：工厂角色（能根据业务动态选择生产哪些产品）、抽象产品角色（产品有哪些特点，能做什么）、具体产品角色（产品怎么做）
  • 简单工厂乐器类

  1
  interface Playable { public void play();}
  2
  
  3
  class Wind implements Playable{
  4
      public void play(){System.out.println("管乐器~~吹");}
  5
  }
  6
  class Percussion implements Playable {
  7
      public void play(){System.out.println("打击乐器~~打");}
  8
  }
  9
  class Stringed implements Playable{
  10
      public void play(){System.out.println("弦乐器~~弹");}
  11
  }
  12
  
  13
  class InstrumentFactory {
  14
      public static Playable createInstrument(String insName) {
  15
          if ("wind".equals(insName)) {
  16
              return new Wind();
  17
          } else if ("percussion".equals(insName)){
  18
              return new Percussion();
  19
          } else if ("stringed".equals(insName)) {
  20
              return new Stringed();
  21
          } else return null;
  22
      }
  23
  }
  24
  
  25
  public class SimpleFactoryMain {
  26
      public static void main(String[] args) {
  27
          Playable aWind = InstrumentFactory.createInstrument("wind");
  28
          Playable aPercussion = InstrumentFactory.createInstrument("percussion");
  29
          Playable aStringed = InstrumentFactory.createInstrument("stringed");
  30
          if (aWind != null) aWind.play();
  31
          if (aPercussion != null) aPercussion.play();
  32
          if (aStringed != null) aStringed.play();
  33
      }
  34
  }

  Show moreShow less

包#

• 作用

  • 包能够让程序员将类组织成单元，通过文件夹或目录来组织文件和应用程序；
  • 包减少了名称冲突带来的问题，可以防止同名的类发生冲突；
  • 包能够更大面积的保护类、变量和方法，而不是分别对每个类进行保护；
  • 包可以用于标示类。

• 创建：说明语句必须放在整个.java文件的第一行。可以在不同的文件中使用相同的包说明语句，这样就可以将不同文件中的类都包含到相同的程序包中。

• 包的引用

  • 使用全名引用

    • 同包的类相互引用时：在使用的属性或方法名前加上类名作为前缀即可
    • 不同包中的类相互引用时：在类名的前面再加上包名，类的全名

  • 使用import

    import可以加载整个包中的文件或包中的某一个文件。

Java变量及其传递#

• 成员变量与局部变量区别

  • 从语法形式上看：成员变量是属于类或接口的，而局部变量是在方法中定义的变量或方法的参变量；成员变量可以被public，private，static等修饰，而局部变量则不能被访问控制符及static修饰；成员变量及局部变量都可以被final修饰。
  • 从变量在内存中的存储方式看：成员变量是对象的一部分，而对象是存在于堆中的，而局部变量是存在于栈中的。
  • 从变量在内存中的存在时间上看：成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而产生，随着方法调用结束而自动消失。
  • 成员变量如果没有赋初值，则会自动以该类型的默认值（0,false,null等）赋值；而局部变量则不会自动赋值，必须显示地赋值后才能使用。

• 变量的传递

  • Java中方法参数传递方式是按值传递。如果参数是基本类型，传递的是基本类型的字面量值的拷贝。如果参数是引用类型，传递的是该参量所引用的对象在堆中地址值的拷贝。

  • 其他知乎解答

  • 对于基本类型的变量形参修改了并不能反映到函数外面的实参

  • 对于引用类型的变量，在形参中修改了对象实体值可以反映到实参，在形参中修改了对象引用值，不能反映到实参

  • String和StringBuffer的其他区别：

    1. StirngBuffer是可以变话的，如果改变了StringBuffer变量的长度或内容，不会改变对这个对象的引用。
    2. String是固定的，如果改变了String变量的长度或内容，就会新建一个String对象，原来的String变量会指向新的String对象。

• 引用型变量的比较

  • 问题引入：==和!=用来比较引用型变量时,只能判断运算符两边引用的是不是同一个对象,即对象的地址值（或对象引用值）是不是相同，需要用equals()方法比较两个对象的内容(对象实体值)是否相同。

  • ps：Java为节省内存空间、提高运行效率，编译时将String Pool中所有相同的字符串合并，只占用一个空间。导致引用变量a和b指向同一个对象。

    1
    String a=new String("hello");
    2
    String b=new String("hello");
    3
    System.out.println(a==b);        //false
    4
    System.out.println(a.equals(b)); //true
    5
    String c="hello";
    6
    String d="hello";
    7
    System.out.println(c==d);        //true
    8
    System.out.println(c.equals(d)); //true

  • 自己定义的类如果要支持equals方法必须重写从Object类继承来的equals方法

    1
    //Object类中的equals方法
    2
    public boolean equals(Object obj) {
    3
      return (this==obj);
    4
    }

内部类#

• 内部类不能与外部类同名（否则，编译器无法区分内部类与外部类），如果内部类还有内部类，内部类的内部类不能与它的任何一层外部类同名。
• 创建
  • 创建非静态内部类的对象时一定要确保已经有一个外部类对象
    • 利用外部类的方法创建并返回，因为方法是由外部类对象调用的，那创建该内部类对象时，一定已经拥有了所属的外部类对象了
    • 创建内部类还可以在除外部类中的其它类中，但是要确保该类具有访问内部类的权限，并且已经创建了一个外部类对象。
  • 内部类的修饰符
  • 静态内部类
    • 实例化static内部类时，在new前面不需要用对象变量
    • static内部类中不能访问其外部类的非static属性及方法，即只能访问static成员
    • 方法中的内部类，可以访问其外部类的成员；若是static方法中的内部类，可以访问外部类的static成员。
    • 方法中的内部类，不能访问该方法的局部变量，除非是final的局部变量。
• 使用
  • 内部类中访问外部类的成员
    • 内部类中是可以直接访问外部类的其他属性与方法的，即使它们是private的。
    • 如果内部类中有与外部类同名的属性与方法，可以使用outerClass.this.x或this.x的格式来表达外部类的引用，从而区分外部类和内部类的同名的属性与方法。
  • 方法和作用域中的内部类
• 匿名内部类
  • 这种类不取名字，而直接用其父类的名字或者它所实现的接口的名字
  • 类的定义与创建该类的一个对象同时进行，即类的定义前面有一个new，没有类的首部，对象的创建和类体共同构成一个匿名类表达式，后面以“;”结束；
  • 类中不能定义构造方法，因为它没有名字。

异常处理#

概念#

• Java把程序运行过程中可能遇到的问题分为两类，一类是致命性的，即程序遇到了非常严重的不正常状态，不能简单地恢复执行，这就是错误(对应Error类)，如程序运行过程中内存耗尽。另一类是非致命性的，通过某种处理后程序还能继续运行，这就是异常(对应Exception类)。
• 按异常在编译时是否被检测来分，Exception类子类有两种：运行时异常和非运行时异常（一般异常）
  • 运行时异常：RuntimeException类及其所有子类。运行时异常是程序员编写程序不正确所导致的异常，理论上，程序员经过检查和测试可以查出这类错误。如除数为零等，错误的强制类型转换、数组越界访问、空引用。
  • 非运行时异常（一般异常）：指可以由编译器在编译时检测到的、可能会发生在方法执行过程中的异常，如找不到指定的文件等，这不是程序本身的错误，如果这些异常情况没有发生，程序本身仍然是完好的
• 处理异常的三种方法
  • 用户可以用try-catch-finally语句进行捕获和处理
  • 如果不想捕获和处理异常，可以通过throws语句声明要抛出的异常
  • 用户可以定义自己的异常类,并用throw语句来抛出。

try-catch-finally#

1
//访问文本文件text.txt，并将其在屏幕上打印出来。
2
import java.io.*;
3
class TryCatchFinally {
4
    public static void main(String args[]) {
5
        try {
6
            FileInputStream in =
7
                new FileInputStream("text.txt");
8
            int s;
9
            while((s=in.read())!=-1)
10
                System.out.print(s);
11
            in.close();
12
        } catch(FileNotFoundException e) {
13
            System.out.println("捕获异常："+e);
14
        } catch(IOException e) {
15
      System.out.println("捕获异常："+e);
16
        } finally {
17
      System.out.println("finally块总是执行！");
18
        }
19
    }
20
}

• 当产生的异常找到了第一个与之相匹配的参数时，就执行包含这一参数的catch语句中的Java代码，执行完catch语句后，程序恢复执行，但不会回到异常发生处继续执行，而是执行try-catch结构后面的代码。
• 可以用一个catch块来处理多个异常类型，此时catch的参数应该是这多个异常的父类。
• 有多个catch块时，要细心安排catch块的顺序。将子类的catch块放在前面，父类的catch块放在后面。
• 执行过程
  • try块中的语句没有产生异常。在这种情况下，Java首先执行try块中的所有的语句，然后执行finally子句中的代码，最后执行try…catch..finally块后面的语句；
  • try块中的语句产生了异常，而且此异常在方法内被捕获。在这种情况下，Java首先执行try块中的语句，直到产生异常处，然后跳过此try块中剩下的语句，执行捕获此异常的catch子句的处理代码；然后执行finally子句中的代码
  • 如果在catch子句又重新抛出了异常。也会执行finally，然后将这个异常抛出给方法的调用者；
  • try块中产生了异常，而此异常在方法内没有被捕获。在这种情况下，Java将执行try块中的代码直到产生异常，然后跳过try块中的代码而转去执行finally子句中的代码，最后将异常抛出给方法的调用者。

throws抛出异常#

不捕获异常，而是将异常交由上一层处理，在其他地方捕获异常。如果使用后者，那么应该（在某些情况下）向编译器表明：此方法可能会抛出异常，但方法本身不会捕获它。可以在方法头中用throws子句来实现此功能。

1
// 1.调用的方法抛出了异常
2
class Test {
3
    ……
4
  public String getInput() throws IOException {
5
    ……
6
      System.in.read();
7
  }
8
}
9

10
// 2.检测到了错误并使用throw语句抛出异常
11
import java.io.*;
12
class Test {
13
    ……
14
  public String getInput() throws IOException {
15
    ……
16
    IOException ae =
17
            new IOException("buffer is full");
18
    throw ae;
19
  }
20
}

throw抛出异常#

• 一般这种抛出异常的语句应该在满足一定条件执行，例如把throw语句if分支中
• 含有throw语句的方法，应该在方法头定义中用throws语句声明所有可能抛出的异常
• 抛出异常三步：确定异常类；创建异常类的实例；抛出异常。

类库#

java.lang#

• String

  • 可创建一个对象，用于代表一个字符串(不变的字符串)，并定义了类似查找，比较和连接字符的操作。所有字符串常量都是String对象，存储在String Pool（字符串池）中，字符串池是常量池的一部分。

  • String类对象一旦创建，其内容不可更改。String类的所有方法都不会改变String类对象内容，要改变String类对象的值就必须创建一个新的String对象。

  • String是类，在比较字符串内容时，不能用==，而应该用equals方法。String类覆盖了Object类的equals方法

  1
  //求字串，前闭后开
  2
  String a="hello";
  3
  String b=a.substring(0,4); // 得到hell
  4
  
  5
  //长度
  6
  String c="hello你好";
  7
  int d=c.length();          // 得到7
  8
  
  9
  //得到字符串中指定下标的字符。
  10
  String a=”hello”; char b;
  11
  b=a.charAt(0);             // 得到下标为0的字符h
  12
  
  13
  //字符数组转换为String
  14
  char[] a={'a','b','c','d'};
  15
  String b=new String(a);
  16
  
  17
  //String转换为字符数组
  18
  String a="hello";
  19
  char[] b=a.toCharArray();
  20
  
  21
  //字节数组转换为String
  22
  byte[] a={65,66,67,68};
  23
  String b=new String(a);    // 得到ABCD
  24
  
  25
  //大小写转换
  26
  String s1="Hello";
  27
  String s2=s1.toUpperCase(); // 得到HELLO
  28
  String s3=s1.toLowerCase(); // 得到hello
  29
  
  30
  //其他数据类型to字符串
  31
  String out2 = String.valueOf(100);
  32
  String out3 = ""+100;
  33
  String out1 = new Integer(100).toString();

  Show moreShow less

• StringBuffer

  1
  //三种创建方法
  2
  public StringBuffer()；
  3
  public StringBuffer(int length)；
  4
  public StringBuffer(String str)；
  5
  
  6
  //更新
  7
  StringBuffer s=new StringBuffer("hello");
  8
  s.append("java");   // s变为hellojava
  9
  s.insert(5,"sun");  // s变为hellosunjava
  10
  s.setCharAt(0,'H'); // s变为Hellosunjava
  11
  s.delete(5,8);      // s变为Hellojava
  12
  
  13
  //StringBuffer对象和String对象的转换
  14
  StringBuffer s = new StringBuffer("hello");
  15
  String a = s.toString();

  Show moreShow less

• 数据类型类

  1
  //将字符串转换为int型
  2
  String s = "1234";
  3
  int i = Integer.parseInt(s);
  4
  int i = Integer.parseInt(s,16); //16进制
  5
  
  6
  
  7
  //将int型转换为字符串
  8
  int i = 1234;
  9
  String s = Integer.toString(i);

• Math

  1
  //PI
  2
  double x = Math.PI
  3
  
  4
  //接受一个double类型的弧度值,返回类型均为double
  5
  sin(double a) //返回弧度a的sin值
  6
  cos(double a) //返回弧度a的cos值
  7
  tan(double a) //返回弧度a的tan值
  8
  
  9
  //反三角函数，返回类型均为double型。
  10
  asin(double r) //返回sin值为r的弧度
  11
  acos(double r) //返回cos值为r的弧度
  12
  atan(double r) //返回tan值为r的弧度
  13
  
  14
  //返回类型均为double型
  15
  pow(double x, double y) //返回x^y。
  16
  exp(double x)           //返回e^x
  17
  log(double x)           //返回log_e(x)。
  18
  sqrt(double x)          //返回x的平方根。
  19
  
  20
  //取整
  21
  ceil(double a)  //返回double
  22
  floor(double a) //返回double
  23
  rint(double a)  //返回四舍五入后的整数值，double
  24
  round(float a)  //返回四舍五入后的整数值, int
  25
  round(double a) //返回四舍五入后的整数值, long
  26
  
  27
  //要求a、b类型相同，返回类型一致
  28
  max(a,b)  //返回a和b的最大值
  29
  min(a,b)  //返回a和b的最小值
  30
  
  31
  //随机数
  32
  random(); //得到一个[0,1)之间的随机数，返回double
  33
  (int)(Math.random()*60 + 20)
  34
  (int)(Math.random()*60)+ 20
  35
  //使用随机函数获得20~80的随机整数

  Show moreShow less

java.util#

• 日期时间类

  1
  //构造
  2
  public Date()
  3
  public Date(int year, int month, int date)
  4
  public Date(int year, int month, int date, int hours,int minutes)
  5
  public Date(int year, int month, int date, int hours, int minutes, int seconds)
  6
  
  7
  //获取
  8
  public int getYear();
  9
  public int getMonth();
  10
  public int getDate();
  11
  public int getDay();
  12
  public int getHours();
  13
  public int getMinutes();
  14
  public int getSeconds();
  15
  public boolean before(Date when);
  16
  
  17
  //比较
  18
  public boolean before(Date when)；
  19
  public boolean after(Date when);
  20
  public boolean equals(Object obj);
  21
  
  22
  //转换
  23
  public String toString()

  Show moreShow less

• vector<E>

  1
  //构造
  2
  Vector();
  3
  Vector(int capacity);
  4
  Vector(int capacity, int capacityIncrement);
  5
  //eg
  6
  Vector<String> vector1=new Vector<String>(5);
  7
  
  8
  //修改
  9
  boolean add(E e);
  10
  void insertElementAt(E obj, int index);
  11
  void setElementAt(E obj, int index);
  12
  void removeElementAt(int index);
  13
  clear()
  14
  
  15
  //获取
  16
  boolean contains(Object o);
  17
  int indexOf(Object o);
  18
  E elementAt(int index);
  19
  int capacity()
  20
  int size()

  Show moreShow less

• Hashtable<K,V>

  1
  new Hashtable <K,V>();
  2
  V put (K key, V value);
  3
  V get (Object key); //关键字匹配
  4
  V remove(Object key);

  • 覆盖equals方法和hashCode方法
    • 原因：关键字匹配时，系统会自动调用关键字的equals方法，如果结果为true且两个关键字的hashCode()方法的结果也相等，则匹配成功。如果没有在关键字类中覆盖equals方法和hashCode方法，则系统会去调用继承自Object类的equals方法和继承自Object类的hashCode方法。Object类的equals方法是在比较两个对象的地址。Object类的hashCode方法是计算对象的地址的散列值。所以这时就算两个关键字对象实体值（即对象内容）相同，也不会匹配。
    • 要求
      • 值相同的两个关键字对象用equals方法比较后相等
      • 值相同的两个关键字对象的hashCode方法结果相等

  1
  class A {
  2
      int date;
  3
      public boolean equals(Object obj) {
  4
        A aobj=null;
  5
         if (obj instanceof A) {
  6
        aobj=(A)obj;
  7
            if (this.date==aobj.date)
  8
                return true;
  9
            else return false;
  10
         }
  11
         else return false;
  12
      }
  13
      public int hashCode() { return date;}
  14
  }

• Stack<E>

  1
  Stack()
  2
  E push (E item)
  3
  E pop ()
  4
  E peek()
  5
  boolean empty()

• 集合类

• Arrays

  1
  //使用Arrays.sort来对数组排序
  2
  java.util.Arrays.sort(x);
  3
  
  4
  //使用Arrays.binarySearch函数对数组进行二分查找
  5
  //如果没找到，则会输出负数
  6
  java.util.Arrays.binarySearch(x,1));
  7
  
  8
  //数组x中的4个元素都改为7
  9
  java.util.Arrays.fill(x,7);

java.io#

• 字节流

  • InputStream和OutputStream是所有面向字节的输入输出流的超类

    1
    public int read() throws IOException
    2
    public int read( byte[] b ) throws IOException
    3
    public int read( byte[] b, int off, int len ) throws IOException
    4
    void write(int b) throws IOException
    5
    void write( byte[] b ) throws IOException
    6
    void write( byte[] b, int off, int len ) throws IOException

  • FileInputStream和FileOutputStream

    1
    FileInputStream fs=new FileInputStream("a.txt");
    2
    File file=new File ("a.txt");
    3
    FileInputStream fs=new FileInputStream(file);
    4
    
    5
    FileOutputStream(File file)
    6
    FileOutputStream(File file, boolean append)
    7
    FileOutputStream(FileDescriptor fdObj)
    8
    FileOutputStream(String name)
    9
    FileOutputStream(String name, boolean append)

  • 过滤流

    必须将过滤流和节点流连接。连接是通过在过滤流的构造方法中指定入口参数——某个节点流对象来实现的。

    1
    FileInputStream in=new FileInputStream(“text”);
    2
    BufferedInputStream bufin=new BufferedInputStream(in);

    • BufferedInputStream和BufferedOutputStream

      1
      public BufferedInputStream(InputStream in); public BufferedInputStream(InputStream in,int size);

    • ObjectInputStream和ObjectOutputStream

• 字符流

  • Reader和Writer

    是所有面向字符的输入输出流的超类

    1
    public int read() throws IOException
    2
    public int read(char[] cbuf) throws IOException
    3
    public int read(char[] cbuf,int off,int len) throws IOException
    4
    void write(String str) throws IOException
    5
    void write(char[] cbuf) throws IOException
    6
    void write(char[] cbuf,int off,int len) throws IOException

  • FileReader和FileWriter

    1
    File f=new File(“d:\\t1.txt”);
    2
    FileReader f1=new FileReader(f);
    3
    FileReader f2=new FileReader(“d:\\t1.txt”);
    4
    
    5
    File f=new File(“d:\\t1.txt”);
    6
    FileWriter f1=new FileWriter(f);
    7
    FileWriter f2=new FileWriter(“d:\\t1.txt”);

  • InputStreamReader和OutputStreamReader

    把字节流转换成字符流

    1
    public InputStreamReader(InputStream in)
    2
    public InputStreamReader(InputStream in,String enc)
    3
    public OutputStreamWriter(OutputStream out);
    4
    public OutputStreamWriter(OutputStream out,String enc)

• 输入汉字的时候，因为相当于读取了字符的高/低位字节，并未读取完整的汉字。因此需要将字节流转换为字符流。

  1
  InputStreamReader isr=new InputStreamReader(System.in);
  2
    try {
  3
      c=(char)isr.read();
  4
      System.out.println(c);
  5
      } catch (IOException e){}

• File

  • 在Java中目录和文件都用File类表示，File类建立了Java语言和磁盘文件的联系，File类不能于文件内容的访问。

  1
  //构造
  2
  File(String pathname)
  3
  File(File parent, String child)
  4
  File(String parent, String child)
  5
  File(URI uri)
  6
  
  7
  /* pathname和child指定文件名；
  8
  parent指定目录名，目录名既可以是字符串，也可以是File对象；
  9
  uri是统一资源标识符（见java.net包）
  10
  要表示‘\’字符（反斜杠）要用转义字符‘\\’ */
  11
  
  12
  //文件操作类方法
  13
  public boolean createNewFile()
  14
  public boolean renameTo(File dest)
  15
  public boolean delete()
  16
  
  17
  //目录操作类方法
  18
  public boolean mkdir()
  19
  public String[] list()
  20
  public File[] listFiles()
  21
  
  22
  //获取文件属性
  23
  ...
  24
  
  25
  //使用File类创建文件、目录
  26
  import java.io.File;
  27
  public class creatFile{
  28
      public static void main(String[] args) {
  29
          try {
  30
              //创建文件
  31
              File f1=new File("H:\\a.txt");
  32
              boolean success=f1.createNewFile();
  33
              //创建目录
  34
              //File f1=new File("H:\\a");
  35
              //boolean success=f1.mkdir();
  36
              if(success) {
  37
                       System.out.println("Creat Successfully");}
  38
              else {
  39
                  System.out.println(f1.getPath());
  40
              }
  41
            } catch(Exception e) {
  42
                   System.out.println(e.toString());
  43
            }
  44
    }
  45
  }

  Show moreShow less

泛型程序设计#

• 泛型的本质是参数化类型，编写的代码可以被很多不同类型的对象或数据所重用，也就是说所操作的数据类型被指定为一个参数。使得程序具有更好的可读性和安全性。

• 访问 List 与 ArrayList 的对比

  

GUI#

Frame(JFrame)#

• Frame类的对象开始是不可见的，要调用show()方法 (或setVisible(true)方法) 才能显示出来，也可以调用hide()方法将其隐藏。框架对象被创建后就可使用add()方法将其它组件加入到框架中。
• Frame和Dialog是Window的子类，它们都是窗口类，默认的布局管理器都是 BorderLayout

1
Frame()        //创建一个不带标题的框架
2
Frame(String)  //创建一个带标题的框架
3

4
show()                  //显示框架
5
setVisible(boolean b)   //使框架可见/不可见
6
hide()                  //隐藏框架
7
setTitle()              //设置框架的标题
8
setSize(int w, int h)   //调整框架的尺寸(宽/高为w/h)
9
setBounds(int x, int y, int w,int h)
10
//调整框架的位置及尺寸(左上角为(x,y), 宽、高为w、h)
11
add(Component ob)
12
//将其它组件ob加入到框架的中心位置
13
add(String p, Component ob)
14
//将组件ob加入到框架的p位置 (框架默认的布局方式是BorderLayout,  它将容器划分为东西南北中)

panel(Jpanel)#

• 面板panel(Jpanel)是能在屏幕上实际显示的组件，提供了容纳其他组件的功能，但本身必须放在Window,Frame,Dialog等容器中才能使用
• 所有面板的默认的布局管理器是FlowLayout,即按照从左至右、从上到下的方式布局
• java.applet.Applet是java.awt.panel的子类

1
import java.awt.*;
2
import java.applet.*;
3
public class ContainerApplet extends Applet
4
{
5
    public void init(){
6
          setLayout(new GridLayout(1,2,10,10));
7
          Panel Panel1=new Panel();
8
          Panel Panel2=new Panel();
9
          add(Panel1);
10
          add(Panel2);
11
          Panel1.add(new Button(“Up”));
12
          Panel1.add(new Button(“Down”));
13
    }
14
 }

button#

流程：定义一个按钮对象；用new实例化按钮对象；（可以与上一步合并）；用add方法将按钮加入容器中。

1
Button()             //生成一个没有标记的按钮
2
Button(String label) //生成一个带标记label的按钮
3

4
setLabel(String label) //设置按钮标记
5
getLabel()             //获取按钮标记
6
setEnabled(boolean)    //能否点击
7
setActionCommand(String s)
8
//设置用户按下按钮时返回的信息
9
addActionListener(ActionListener l)
10
//将l指定为按钮的监听者
11
removeActionListener(ActionListener l)
12
//将l从按钮监听者中去掉

标签(Lable)#

1
la1=new Label();
2
la2=new Label("Label2");
3

4
getAlignment()       //获取对齐方式
5
getText()            //获取文本
6
setAlignment(int aligmnent)  //设置对齐方式 Label.CENTER
7
setText(String text)         //设置文本
8

9
//JLabel中是调用
10
setHorizontalAlignment(SwingConstants.CENTER);

文本框(TextField)#

1
TextField()              //创建一个空的文本框
2
TextField(Strint text)   //创建一个带有初始文本的文本框
3
TextField(int Columns)   //创建一个指定列数的文本框
4
TextField(String text, int colulmns)
5
//创建一个指定列数和带有初始文本的文本框
6

7
addActionListener(ActionListener l)
8
//将l指定为文本框的ActionEvent事件监听者
9
removeActionListener(ActionListener l)
10
//将l从文本框的监听者中去掉
11
setEchoChar(String sc)   //设置用户输入的回应字符'*'密码
12
getEchoChar()            //获取回应字符
13
setText(String s)        //设置文本框中的字符串
14
getText()                //获取文本框中的字符串

布局管理器#

• 边界布局 BorderLayout

  • BorderLayout是容器JFrame和JApplet的默认布局方式**
  • 将容器分成五个区域，NORTH(顶部)，SOUTH(底部)，WEST (左侧)，EAST(右侧)，CENTER(中间)，每个区域最多只能1个组件

  1
  add(new Button("South"), BorderLayout.SOUTH);
  2
  add(new Button("South"),"South");
  3
  add("South",new Button("South"));
  4
  
  5
  BorderLayout()
  6
  //构造一个组件之间没有间距的新边界布局。
  7
  BorderLayout(int hgap, int vgap)
  8
  //用指定的组件之间的水平间距构造一个边界布局。

• 顺序布局 FlowLayout

  • FlowLayout面板Panel和它的子类Applet的默认布局方式
  • 将组件从左到右依次排列，一行排满就转到下一行继续排列，直到所有的组件都排列完毕。

  1
  Frame f=new Frame();
  2
  f.setLayout(new FlowLayout());
  3
  
  4
  public FlowLayout()
  5
  //创建一个新的FlowLayout，其默认值是居中对齐，默认组件彼此有5单位的水平与垂直间距。
  6
  public FlowLayout(int align)
  7
  //创建一个新的FlowLayout，此FlowLayout可以设置对齐（align）方式，对齐必须是LEFT、CENTER或RIGHT之一。默认组件彼此有5单位的水平与垂直间距。
  8
  public FlowLayout(int align,int hgap,int vgap)
  9
  //创建一个新的FlowLayout，可以自己设置对齐方式、水平间隔和垂直间隔。

• 网格布局 GridLayout

  • 网格布局比顺序布局多了行和列的设置，也就是说要先设置网格布局共有几行几列。然后加进去的组件会先填完第一行格子，然后再从第二行开始填，依此类推，就像是一个个的格子一般。而且网格布局会将填进去的组件大小设为一样。

  1
  public GridLayout()
  2
  public GridLayout(int rows,int cols)
  3
  public GridLayout(int rows,int cols,int hgap,int vgap)

事件处理#

• 事件源：事件源是一个事件的产生者。各种图形组件都可以作为事件源

• 事件对象

  • 图形组件产生的事件
  • 一个事件对象包含了以下信息：id----事件的类型。如按键事件、单击鼠标事件等。target----发生事件的对象。when----指出事件发生的时间。x, y----发生事件的坐标。key----键盘事件中被按下的键。arg----一个与事件相关的参数。modifier----修饰键的状态(即Alt,Ctrl键的状态)
  • 主要的事件对象
    • ComponentEvent（ 组件事件：组件尺寸的变化，移动）
    • ContainerEvent（ 容器事件：组件增加，移动）
    • WindowEvent（ 窗口事件：关闭窗口，窗口闭合，图标化）
    • FocusEvent（ 焦点事件：焦点的获得和丢失）
    • KeyEvent（ 键盘事件：键按下、释放）
    • MouseEvent（ 鼠标事件：鼠标单击，移动）
    • ActionEvent（动作事件：按钮按下，TextField中按Enter键）
    • TextEvent（文本事件：文本对象改变）

  1
  public interface KeyListener extends EventListener
  2
  {public void keyPressed(KeyEvent ev); …}

• 事件监听器

  • 事件监听器就是一个接收事件、解释事件并处理用户交互的方法。事件产生以后，不是由事件源或者其容器对象处理事件，而是将事件委托给事件监听器来处理。监听器包含事件处理程序。
  • 事件源和监听器对象通过注册的方式建立关联。当事件源发生事件时，事件监听者就代替事件源对事件进行处理。
  • 每类事件都有对应的事件监听器，监听器是接口，根据动作来定义方法。

• 事件的处理方法流程

  • 明确事件源是什么，也就是什么组件要被处理。
  • 明确什么样的事件要被处理。
  • 在事件监听器的相应事件响应函数中实现自己的功能。

  1
  import java.awt.*;
  2
  import java.awt.event.*;
  3
  public class test {
  4
      public static void main(String []args) {
  5
          Frame f=new Frame("我的第一个窗口");
  6
          f.setSize(400,300);
  7
          f.setLayout(null);
  8
          f.addWindowListener(new MyWindowAdapter());
  9
          f.setVisible(true);
  10
          //创建窗口后要调用setVisible(true)才能显示出来
  11
      }
  12
  }
  13
  
  14
  class MyWindowAdapter extends WindowAdapter
  15
  {public void windowClosing(WindowEvent e)
  16
  {System.exit(0);}}
  17
  
  18
  //创建了一个匿名内部类对象
  19
  import java.awt.*;
  20
  import java.awt.event.*;
  21
  public class test {
  22
      public static void main(String []args) {
  23
          Frame f=new Frame("我的第一个窗口");
  24
          f.setSize(400,300);
  25
          f.setLayout(null);
  26
          f.addWindowListener(new WindowAdapter() {
  27
              public void windowClosing(WindowEvent e) {
  28
                  System.exit(0);
  29
              }
  30
          });
  31
          f.setVisible(true);
  32
          //创建窗口后要调用setVisible(true)才能显示出来
  33
      }
  34
  }
  35
  
  36
  //按钮上响应点击鼠标事件（MouseClicked）为例
  37
  JButton jButton1 = new JButton();
  38
  jButton1.addMouseListener(new MymouseAdapter());
  39
  class MymouseAdapter extends MouseAdapter
  40
  {public void mouseClicked(MouseEvent e) {……}}
  41
  //或者匿名内部类
  42
  frame.add(jButton1);
  43
  //元件要 add()

  Show moreShow less

字体、颜色外观#

1
//颜色和字体setBackground, setForeground, setFont
2
//位置和大小setBounds, setLocation, setSize
3
import java.awt.*;
4
public class Demo
5
{
6
    static Font ff=new Font("黑体", Font.ITALIC, 30);
7
    public static void main(String args[])
8
    {
9
        Frame f=new Frame();
10
        f.setLayout(new FlowLayout());
11
        Button b1=new Button("B1");
12
        Button b2=new Button("B2");
13
        b2.setBackground(Color.blue);
14
        b2.setForeground(new Color(200,100,0));//红
15
        b2.setFont(ff);
16
        b1.setBounds(30,40,60,20);
17
       b2.setLocation(100,40);
18
       b2.setSize(50,50);
19
        f.add(b1);
20
        f.add(b2);
21
        f.setSize(180,100);
22
        f.show();
23
    }
24
}