一个Main Class，巩固java基础

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;


public class SubClassMain extends BaseClass implements IInterface{
/*
* 一个java文件中可以有多个pulbic class
*/
public class InnerClass{

}
static class StaticInnerClass{

}
    /*
     * main方法也可以被重载哦
     */
    public static void main(String[] args,int k){
   
    //return 0;
    }
public static void main(String[] args) {

  StringBuffer z = new StringBuffer("a");
  StringBuffer y = new StringBuffer("be");
  /*
   * 对象当做参数传入外部方法时，属于对象引用，方法内对值得修改
   * 一直会影响这个对象
   */
  methodA(z,y);
  System.out.println(z+","+y);
  IInterface ii = new SubClassMain();
  BaseClass a = new SubClassMain();
  SubClassMain d = new SubClassMain();
 
  /*
   * 同一个类中，基类和接口可以使用相同的属性名和方法名，但调用只能声明以接口或者基类调用
   * 否则具有二义性，造成语法错误
   */
  System.out.println("ii.x:"+ii.x+",a.x:"+a.x);

  /*
   * 接口可以作为实现类数组的引用
   * 当数组被实例化时，不需要声明数组大小，否则语法错位
   * IInterface ab[] = new IInterface[2]{new SubClassMain(),new SubClassMain()};
   */
  IInterface ab[] = new IInterface[]{new SubClassMain(),new SubClassMain()};
  int iii = ab[1].FS;
  /*
   *ab[1].FS = 5; //写法错误。final类型不能被重新赋值
   */
  System.out.println("IInterface.FS:"+IInterface.FS+",iii:"+iii);
  /*
   * 首先调用子类重写的方法，找不到则调用基类的方法
   */
  System.out.println("a.ff:"+a.ff(2));
  NormalClass c = new NormalClass();
  gg(c);
  gg(c);
  gg(c);
  /*
   * 静态方法修改的是全局的变量，每次操作都叠加有效
   */
  System.out.println("cx:"+c.x);
  String s = "me";
  /*
   * String 作为参数是值引用，final型
   */
  ss(s);
  System.out.println("s:"+s);
 
  c.ff(0);
  /*
   * String 作为参数是值引用，final型
   */
      d.ee(s);
      System.out.println("s:"+s);
      List lst = new ArrayList();
      lst.add("ddd");
      lst.add("ddd");
      lst.add(new NormalClass());
      /*
       * List 可以插入重复的值，并保持顺序
       * List 默认的toString()方法，格式为[ddd, ddd, CC@4a604a60]
       */
      System.out.println(lst);
      /*
       * 此声明合法，为十六进制和八进制的整形
       */
      int i = 0xFFFFFFF1;
      int j = 034;
      System.out.println("i:"+i+"~i:"+~i+",j:"+j);
     
      /*
       * 声明float数据，必须以f结尾
       */
      float fl = 3.2f;
      /*
       * byte,short,int,long,char
       * float,double,
       * boolean 数据基本数据类型
       */
      long l = -3;
      short o = -3;
      int in = -4;
      byte bb = -3;
      /*
       * 这样也行，奇怪！
       */
      char ch ='4',ch2 = 4;
     
      Float flo = new Float(3.2f);
      Double dou = new Double(flo);
      /*
       * true,false,ture
       */
      System.out.println(flo==fl);
      System.out.println(flo.equals(dou));
      System.out.println(flo.equals(fl));
     
      try{
      System.out.println("d.mm:"+d.mm());
      d.tt();
      /*
       * thorw 之后的方法不再被执行
       */
      System.out.println("tt not run");
      }
      /*
       *异常要么被捕获要么被抛出，二者必选其一
       */
      catch (IOException e) {
      System.out.println("IOexception");
      }catch (Exception e) {
//已经被子类捕获的异常，在catch父类中不会被执行
      System.out.println("exception");
      }
      finally{
      /*
       * finally语句在return之前执行
       */
      l=4;
      System.out.println("ttf");
      }
      /*
       * 内部类的声明方法
       */
      InnerClass IC = d.new InnerClass();
      /*
       * 静态内部类的声明方式
       */
      StaticInnerClass ss = new SubClassMain.StaticInnerClass();
}

static StringBuffer methodA(StringBuffer s1, StringBuffer s2) {
  return s1.append(s2);
}


/*
*方法名相同，参数列表不同，返回值类型不同，是允许的
*重写方法的范围不能缩小为private
*/
public void ff(int f,int t) {
//return 1;
}
public int ff(int f) {
return f;
}
public static void gg(NormalClass c){
c.x++;
}
public static void ss(String s){
s = "changed by ss";
}
public void ee(String s){
s = "changed by ee";
}
public void tt() throws IOException{
throw new IOException();
}
public short mm() {
double d = 4.3334444444d;
//double类型，不能被隐式转为short型。只能显示地转型
short ss = (short)d;
return ss;
}


}

interface IInterface{
//接口的属性全部（默认）为static final型
public int x = 1;
public int FS = 4;
}
abstract class BaseClass{
public int x ;
/*
* 不同参数类型的同名方法属于重载。
* 如果返回值类型也不相同不属于重载，但此时不能有相同的参数列表，
* 否则java无法确认你要调用哪个方法
*/
public void ff(){}
public int ff(int x){ return 0;}
}
class NormalClass{
public int x = 3;
boolean bb =false;
public void ff(){}
public int ff(int x){
  /*
   * 在外部时，内部类的声明方式：需要外部内引用
   */
  SubClassMain.InnerClass IC = new SubClassMain().new InnerClass();
  SubClassMain.StaticInnerClass ss = new SubClassMain.StaticInnerClass();
   /*
   * 赋给bb什么值，则"bb=true"返回什么值，如果bb是int类型，则语法错误。
   */
if(bb=true){
System.out.println("bb:"+bb);
}
return 0;
}
}