import java.util.Arrays;
 
public class User implements Comparable {
 
  private String id;
  private int age;
 
  public User(String id, int age) {
    this.id = id;
    this.age = age;
  }
 
  public int getAge() {
    return age;
  }
 
  public void setAge(int age) {
    this.age = age;
  }
 
  public String getId() {
    return id;
  }
 
  public void setId(String id) {
    this.id = id;
  }
 
  public int compareTo(Object o) {
    return this.age - ((User) o).getAge();
  }
 
  /**
   * 测试方法
   */
  public static void main(String[] args) {
    User[] users = new User[] { new User("a", 30), new User("b", 20) };
    Arrays.sort(users);
    for (int i = 0; i < users.length; i++) {
      User user = users[i];
      System.out.println(user.getId() + " " + user.getAge());
    }
  }
 
}

import java.util.Arrays;
import java.util.Comparator;
 
public class SampleComparator implements Comparator {
 
  public int compare(Object o1, Object o2) {
    return toInt(o1) - toInt(o2);
  }
 
  private int toInt(Object o) {
    String str = (String) o;
    str = str.replaceAll("一", "1");
    str = str.replaceAll("二", "2");
    str = str.replaceAll("三", "3");
    //
    return Integer.parseInt(str);
  }
 
  /**
   * 测试方法
   */
  public static void main(String[] args) {
    String[] array = new String[] { "一二", "三", "二" };
    Arrays.sort(array, new SampleComparator());
    for (int i = 0; i < array.length; i++) {
      System.out.println(array[i]);
    }
  }
 
}

//PackageClass.java
package com.fatkun.util;
/**
 * 在包com.fatkun.util内，分别有a,b,c,d四个变量，它们的修饰符都不一样。
 * @author fatkun
 *
 */
public class PackageClass {
	private int a;
	int b;
	protected int c;
	public int d;
 
	public static void main(String[] args) {
		PackageClass p = new PackageClass();
		System.out.println(p.a);
		System.out.println(p.b);
		System.out.println(p.c);
		System.out.println(p.d);
 
		new InsideClass();
	}
 
}
class InsideClass {
 
}

//AnotherPackageClass.java
package com.fatkun.util;
 
/**
 * 同一个包内的类，private的不能访问
 * @author fatkun
 *
 */
public class AnotherPackageClass {
 
	public static void main(String[] args){
		PackageClass p = new PackageClass();
		System.out.println(p.a);//private只能在类内部访问
		System.out.println(p.b);
		System.out.println(p.c);
		System.out.println(p.d);
 
		//内部类在同一个包内可以访问
		new InsideClass();
	}
 
}

//ExtendClass.java
import com.fatkun.util.*;
/**
 * PackageClass的子类
 * @author fatkun
 *
 */
public class ExtendClass extends PackageClass {
 
	public static void main(String[] args) {
		ExtendClass e = new ExtendClass();
		System.out.println(e.a);//private只能在类内部访问
		System.out.println(e.b);//default只能在类内部和同一个包内访问
		System.out.println(e.c);//protect能在子类访问
		System.out.println(e.d);
 
		//内部类在子类不可以访问
		new InsideClass();
	}
}

//DefaultClass.java
import com.fatkun.util.*;
/**
 * 不同包内
 * @author fatkun
 *
 */
public class DefaultClass {
 
	public static void main(String[] args) {
		PackageClass p = new PackageClass();
		System.out.println(p.a);//private只能在类内部访问
		System.out.println(p.b);//default只能在类内部和同一个包内访问
		System.out.println(p.c);//protect只能在类内部、同一个包、子类访问
		System.out.println(p.d);//public能在任何地方访问
 
		//内部类在不同包内不可以访问
		new InsideClass();
	}
 
}

package com.fatkun;
 
/**
 * Overloading（重载，过载）
 * 方法名相同，参数类型不同或者参数类型顺序不同
 * 返回值，访问修饰符，异常可以不一样
 * @author fatkun
 *
 */
public class Overloading {
 
	public int test(){
		System.out.println("test1");
		return 1;
	}
 
	public void test(int a){
		System.out.println("test2");
	}	
 
	//以下两个参数类型顺序不同
	public String test(int a,String s){
		System.out.println("test3");
		return "returntest3";
	}	
 
	public String test(String s,int a){
		System.out.println("test4");
		return "returntest4";
	}	
 
	public static void main(String[] args){
		Overloading o = new Overloading();
		System.out.println(o.test());
		o.test(1);
		System.out.println(o.test(1,"test3"));
		System.out.println(o.test("test4",1));
	}

package com.fatkun;
 
/**
 * Overriding(重写，覆盖)
 * 重写是子类继承父类对父类的方法进行修改。方法名，参数，返回值必须一样。
 * 访问级别的限制性和异常不能比被重写的方法强
 * @author fatkun
 *
 */
class TestClass {
	public void test(){
		System.out.println("这是TestClass的test方法");
	}
}
 
public class Overriding extends TestClass {
 
	public static void main(String[] args) {
		new Overriding().test();
	}
 
	@Override
	public void test() {
		System.out.println("这是Overriding的test方法，重写了TestClass中的方法");
	}
}

public class CalClass {
	static Boolean test(int num){
		System.out.println(num+">2"+(num>2));
		return num>2;
	}
	public static void main(String[] args){
		int i = 1, j =3 , k = 4;
		System.out.println(test(i)||test(j)||test(k));
		System.out.println("end");
	}
}