一个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;
}
}