public class HW_01 {

	public static void main(String[] args) {
		Student student = new Student();
		student.eat();
		student.sleep();
		Teacher teacher = new Teacher();
		teacher.eat();
		teacher.sleep();
	}
}

class Student extends Person {
}

class Teacher extends Person {
}

class Person {
	public void eat() {
		System.out.println("eat...");
	}
	public void sleep() {
		System.out.println("sleep...");
	}
}

public class HW_02_Phone {
	public static void main(String[] args) {

		Phone phone = new Phone();
		phone.call();
		System.out.println();
		phone = new NewPhone();
		phone.call();

	}
}

class Phone {
	/**
	 * 打电话的方法
	 */
	public void call() {
		System.out.println("Phone 打电话...");
	}
}

class NewPhone extends Phone {
	@Override
	public void call() {
		System.out.println("NewPhone 打电话...");
		System.out.println("NewPhone 开启语言...");
		System.out.println("NewPhone 关闭语言...");
	}
}

public class HW_03_Fu {
	public static void main(String[] args) {
		Fu fu = new Fu();
		System.out.println(fu.num);
		Zi zi = new Zi();
		System.out.println(zi.num);
		zi.method();
	}
}

class Fu {
	public int num = 20;

	public Fu() {
		super();
	}
}

class Zi extends Fu {
	public int num = 30;

	public Zi() {
		super();
	}

	public void method() {
		System.out.println(super.num);
	}
}

super.成员方法([参数1,参数2…])

public class HW_04_Fu {
	public static void main(String[] args) {
		Fu1 fu1=new Fu1();
		System.out.println();
		Zi1 zi1=new Zi1();
	}
	
}
class Fu1 {

	public Fu1() {
		super();
		System.out.println("Fu1....");
	}
	
}
class Zi1 extends Fu1 {

	public Zi1() {
		super();
		System.out.println("Zi1....");
	}
}

public class HW_06_FinalTest {
	public static void main(String[] args) {
		Fu_2 fu_2 = new Fu_2();
		Zi_2 zi_2 = new Zi_2();
	}
}
final class Fu_2 {
}
class Zi_2 extends Fu_2 {
}

public class HW_07_FinalMethod {
	public static void main(String[] args) {
		new Fu_7().show();
		new Zi_7().show();
	}
}
class Fu_7 {
	public final void show() {
		System.out.println(Fu_7.class.getTypeName() + ".show...");
	}
}
class Zi_7 extends Fu_7 {
	public void show() {
		System.out.println(Zi_7.class.getTypeName() + ".show...");
	}
}

final int age=18;
age=20;
final int num;
num=12;
num=18;

public class HW_09_FinalField {
	public static void main(String[] args) {
//		new Fu_9();
		new Zi_09();
	}
}
class Fu_9 {
	public final int X;
	public final int Y = 20;
	{
		Y = 30;
	}
	public Fu_9() {
		X = 10;
	}
}
class Zi_09 extends Fu_9 {
	public Zi_09() {
		X = 50;
	}
}

/**
 * 复数的加法
 * 
 * @param a 复数1
 * @param b 复数2
 * @return 复数a加上复数b大的值。
 */
public static Complex add(Complex a, Complex b) {
	Complex result = new Complex();
	result.real = a.real + b.real;
	result.imag = a.imag + b.imag;
	return result;
}

/**
 * 复数减法
 * 
 * @param a 复数1
 * @param b 复数2
 * @return 复数1减去复数2的结果
 */
public static Complex minus(Complex a, Complex b) {
	Complex result = new Complex();
	result.real = a.real - b.real;
	result.imag = a.imag - b.imag;
	return result;
}

/**
 * 求两个复数的乘积
 * 
 * @param first 第一个复数
 * @param second 第二个复数
 * @return 两个复数的乘积
 */
public static Complex times(Complex first, Complex second) {
	Complex result = new Complex();
	result.real = first.real * second.real - first.imag * second.imag;
	result.imag = first.imag * second.real + first.real * second.imag;
	return result;
}

c1 = new Complex(3, 2);
c2 = new Complex(1, 7);
Complex times = Complex.times(c1, c2);
System.out.println(times);

c1 = new Complex(1, 1);
c2 = new Complex(1, 1);
System.out.println(Complex.times(c1, c2));

c1 = new Complex(3, 4);
c2 = new Complex(0, 1);
System.out.println(Complex.times(c1, c2));

/**
 * (A+Bi)/(C+Di)=(A*C+B*D)/(C*C+D*D) + (B*C-A*D)/(C*C+D*D)i
 * (A+Bi)/(C+Di)=(A*C+B*D)/(C*C+D*D) + (B*C-A*D)/(C*C+D*D)i
 * 
 * @param fenZi 分子
 * @param fenMu 分母
 * @return 复数fenZi除以复数fenMu的结果
 */
public static Complex divide(Complex fenZi, Complex fenMu) {
	Complex result = new Complex();
	// A=first.real
	// B=first.imag
	// C=second.real
	// D=second.imag
	result.real = (fenZi.real * fenMu.real + fenZi.imag * fenMu.imag)
	        / (fenMu.real * fenMu.real + fenMu.imag * fenMu.imag);
	result.imag = (fenZi.imag * fenMu.real - fenZi.real * fenMu.imag)
	        / (fenMu.real * fenMu.real + fenMu.imag * fenMu.imag);
	return result;
}

public class Rectangle_02 {
	/**
	 * 矩形的长度
	 */
	private double length;
	/**
	 * 矩形的宽度
	 */
	private double width;

	public Rectangle_02() {
		// TODO Auto-generated constructor stub
	}

	public Rectangle_02(double length, double width) {
		this.length = length;
		this.width = width;
	}

	/**
	 * 求矩形的周长
	 * 
	 * @return 矩形的周长
	 */
	public double perimeter() {
		return 2 * (this.length + this.width);
	}

	/**
	 * 求矩形的面积
	 * 
	 * @return 矩形的面积
	 */
	public double area() {

		return this.length * this.width;
	}

	@Override
	public String toString() {
		return "Rectangle [length=" + length + ", width=" + width + "]";
	}

}

Rectangle_02 r = new Rectangle_02(3, 4);
System.out.println(r + "的周长=" + r.perimeter() + ",面积=" + r.area());

public class HW_02_01_GuessingNumbers {
	private static int v = 100;

	/**
	 * 猜测数字和类中定义个数字的v的大小
	 * 
	 * @param num 整数
	 * @return 如果num大于类中保存的整数v，则返回1，等于则返回0，小于则返回-1
	 */
	public static int guessing(int num) {
		if (num > HW_02_01_GuessingNumbers.v) {
			return 1;
		} else if (num == HW_02_01_GuessingNumbers.v) {
			return 0;
		}
		return -1;
	}

	public static void print(int num) {
		if (HW_02_01_GuessingNumbers.guessing(num) > 0) {
			System.out.println(num + "大了");
		} else if (HW_02_01_GuessingNumbers.guessing(num) == 0) {
			System.out.println(num + "猜测成功");
		} else {
			System.out.println(num + "小了");
		}
	}
}

addSecond(int sec) 
addMinute(int min) 
addHour(int hou) 
subSecond(int sec)
subMinute(int min)
subHour(int hou) 

/**
 * 当前的时间加上{@code h}个小时
 * 
 * @param h 要加上多少个小时
 * @return 当前时间加上{@code h}个小时之后的结果
 */
public HW_02_03_MyTime addHour(int h) {
	int temp = this.hour + h;
	// if (temp > 23)
	// 一天只有24个小时，如果超过了24个小时话需要进位
	// 由于这个类只保存到小时，所以丢弃进位
	this.hour = temp % 24;
	return this;
}
/**
 * 当前时间加上{@code m}个分钟
 * 
 * @param m 要加上多少分钟，可以超过60分钟
 * @return 当前时间加上{@code m}分钟后的时间
 */
public HW_02_03_MyTime addMinute(int m) {
	int temp = this.minute + m;
	if (temp > 59) {
		int hour = temp / 60;
		this.minute = temp % 60;
		// 向小时进位
		addHour(hour);
	} else {
		// 没有进位的情况下直接在分钟上加即可
		this.minute = this.minute + m;
	}
	return this;
}
/**
 * 计算当前时间加上{@code s}秒钟后的时间
 * 
 * @param s 要加上多少秒钟
 * @return 当前时间加上{@code s}}秒钟后的时间
 */
public HW_02_03_MyTime addSecond(int s) {
	int temp = this.second + s;
	// 需要进位的情况
	if (temp > 59) {
		// 需要进位多少
		int minute = temp / 60;
		// 求出进位后的秒值
		this.second = temp % 60;
		// 向分钟进位
		addMinute(minute);
	} else {
		this.second += s;
	}
	return this;
}
/**
 * 当前时间减去{@code h}小时
 * 
 * @param h 需要减去的小时数
 * @return 当前时间减去{@code h}小时后的时间
 */
public HW_02_03_MyTime subHour(int h) {
	int temp = this.hour - h;
	// System.out.println("temp=" + temp);
	// 如果减去的小时比当前的小时数要大，则需要借位
	if (temp < 0) {
		// 小时前面没有更高的位了，直接使用24加上相减的结果即可得到小时数
		this.hour = 24 + temp % 24;
	} else {
		this.hour = temp;
	}
	return this;
}/**
 * 当前时间减去{@code m}分钟
 * 
 * @param m 要减去多少分钟
 * @return 当前时间减去{@code m}分钟后的结果
 */
public HW_02_03_MyTime subMinute(int m) {
	int temp = this.minute - m;
	System.out.println("temp=" + temp);
	if (temp < 0) {
		// System.out.println("temp="+temp);
		// 计算出要减去的小时数
		int hour = -temp / 60;
		subHour(hour + 1);
		// 计算要减去的分钟数
		this.minute = (60 + temp % 60) % 60;
	} else {
		this.minute = temp;
	}
	return this;
}
/**
 * 当前时间减去{@code s}秒钟
 * 
 * @param s 要减去多少秒钟
 * @return 当前时间减去{@code s}秒钟后结果
 */
public HW_02_03_MyTime subSecond(int s) {
	int temp = this.second - s;
	// 相减为负数，则需要借位
	if (temp < 0) {
		// 计算出要减去的小时数
		int minute = -temp / 60;
		System.out.println(minute);
		subMinute(minute);
		// 当temp为0时，括号中的结果为60，此时应该对应0秒,而不是第60秒，
		// 所以最后还要mod60
		this.second = (60 + temp % 60) % 60;
	} else {
		this.second = temp;
	}
	return this;
}

private String name;

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

m=12321;
n=m;
s=0;
while(n>0){
    s=s*10+n%10
    n=n/10;
}

if(s==m){
    // 回文数
}

n=5;
a=2;
s=0;
sn=0;

for(int i=0;;i<n;i++)
{
    sn=sn*10+a;
    s=s+sn;
}
输出s

int max(int x,int y)
double max(double x,double y)

public class Circle {
	// 圆心
	private Point center;
	// 半径
	private double radius;

	public Circle() {
		// TODO Auto-generated constructor stub
	}

	public Circle(Point center, double radius) {
		super();
		this.center = center;
		this.radius = radius;
	}

	/**
	 * 求圆的周长
	 * 
	 * @return 圆的周长
	 */
	public double perimeter() {
		return 2 * Math.PI * radius;
	}

	/**
	 * 求圆的面积
	 * 
	 * @return 圆的面积
	 */
	public double area() {
		return Math.PI * radius * radius;
	}

	/**
	 * 判断两个圆的位置关系
	 * 
	 * @param other 另一个圆
	 * @return 如果两个圆相离，则返回1；
	 *         如果两个圆相交，则返回0；
	 *         如果两个圆相切则返回-1。
	 */
	public int position(Circle other) {
		// 如果两个圆的圆心的距离大于半径
		double radiusSum = this.radius + other.radius;
		if (this.center.distance(other.center) > radiusSum)
			return 1;
		else if (Math.abs(this.center.distance(other.center) - radiusSum) < 1e-6) {
			return 0;
		}
		return -1;
	}
}

public final in MAX=99;

public class Demo{
	public final int MAX;
	public Demo(){
		this.MAX=2;
	}
}

public class GCD_LCM {
	public static void main(String[] args) {
		int a = 12, b = 10;

		a = 4;
		b = 2;
		int gcd = getGCD(a, b);
		System.out.println(a + "和" + b + "的最大公约数为：" + gcd);
		System.out.println(a + "和" + b + "的最小公倍数为：" + lcm(a, b, gcd));
	}

	/**
	 * 辗转相除法求最大公约数入口
	 * 
	 * @param a 一个整数
	 * @param b 另一个整数
	 * @return 整数a和整数b的最大公约数
	 */
	private static int getGCD(int a, int b) {
		if (a > b) {
			return gcd(a, b);
		} else {
			return gcd(b, a);
		}
	}

	/**
	 * 辗转相除法求最大公约数
	 * 
	 * @param big 大的整数
	 * @param small 小的整数
	 * @return big和small这整数的最大公约数
	 */
	private static int gcd(int big, int small) {
		int remainder = big % small;
		if (remainder == 0) {
			return small;
		} else {
			return gcd(small, remainder);
		}
	}

	/**
	 * 求最小公倍数
	 * 
	 * @param a 整数
	 * @param b 另一个整数
	 * @param gcd a和b的最大公约数
	 * @return a和b的最小公倍数
	 */
	private static int lcm(int a, int b, int gcd) {
		return (a * b) / gcd;
	}
}

public class PrimeNumber {
	public static void main(String[] args) {
		for (int i = 2; i < 1000; i++) {
			if (isPrime_sqrt(i)) {
				if (i != 2) {
					System.out.print(",");
				}
				System.out.print(i);
			}
		}
		System.out.println();
	}

	/**
	 * 判断是否是质数
	 * 优化版本1
	 * 
	 * @param n 一个数
	 * @return 如果num是质数的话，返回true,否则返回false.
	 */
	private static boolean isPrime_sqrt(int n) {
		// n只需要被小于等于sqrt(n)的数整除即可判断是否为质数
		int sqrtN = (int) Math.sqrt(n);
		for (int i = 2; i <= sqrtN; i++) {
			// 如果能被小于它的数整除的话，那就不是质数
			if (n % i == 0)
				return false;
		}
		return true;
	}
}

public class MatrixTranspose {
	public static void main(String[] args) {
		int[][] a = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
		printMatrix(a);

		// int[][] b = transposeByCopy(a);
		// System.out.println();
		// printMatrix(b);
		
		System.out.println();
		transpose(a);
		printMatrix(a);
	}
	/**
	 * 矩阵转置（方阵）
	 * @param a 保存正方形矩阵的二维数组
	 */
	private static void transpose(int[][] a) {
		for (int i = 0, temp; i < a.length; i++) {
			for (int j = 0; j < a[i].length; j++) {
				// 交换主对角(j==i)线上下方的元素位置
				if (j < i) {
					temp = a[i][j];
					a[i][j] = a[j][i];
					a[j][i] = temp;
				}
			}
		}
	}
	/**
	 * 矩阵转置
	 * @param a 保存矩阵的二维数组
	 * @return 保存转置后的矩阵的二维数组
	 */
	private static int[][] transposeByCopy(int[][] a) {
		int[][] b = new int[a.length][a[0].length];
		for (int i = 0; i < a.length; i++) {
			for (int j = 0; j < a[i].length; j++) {
				b[j][i] = a[i][j];
			}
		}
		return b;
	}

	/**
	 * 打印矩阵
	 * 
	 * @param a 保存矩阵的二维数组
	 */
	private static void printMatrix(int[][] a) {
		for (int i = 0; i < a.length; i++) {
			System.out.print("│");
			for (int j = 0; j < a[i].length; j++) {
				if (j > 0)
					System.out.print(",");
				System.out.print(a[i][j]);
			}
			System.out.println("│");
		}
	}
}

public class StringStoredInReverseOrder {
	public static void main(String[] args) {
		// char[] ch=new char[100];
		String str = "hello world!!";
		char[] ch = str.toCharArray();
		printChars(ch);
		inverse(ch);
		printChars(ch);
	}
	/**
	 * 反序存放字符串
	 * @param ch 保存字符串的字符数组。
	 */
	private static void inverse(char[] ch) {
		char temp;
		for (int i = 0; i < ch.length / 2; i++) {
			temp = ch[i];
			ch[i] = ch[ch.length - 1 - i];
			ch[ch.length - 1 - i] = temp;
		}
	}

	private static void printChars(char[] ch) {
		for (int i = 0; i < ch.length; i++) {
			System.out.print(ch[i]);
		}
		System.out.println();
	}
}

public class StringConcatenation {
	public static void main(String[] args) {
		String str1 = "hello";
		String str2 = "world";
		char[] ch1 = str1.toCharArray();
		char[] ch2 = str2.toCharArray();

		char[] ch3 = connect(ch1, ch2);
		printChars(ch3);
	}

	/**
	 * 连接两个字符串
	 * 
	 * @param ch1 保存第一个字符串的字符数组
	 * @param ch2 保存另一个字符串的字符数组
	 * @return ch1和ch2串联起来形成的字符数组
	 */
	private static char[] connect(char[] ch1, char[] ch2) {
		char[] ch3 = new char[ch1.length + ch2.length];
		for (int i = 0; i < ch1.length; i++) {
			ch3[i] = ch1[i];
		}
		for (int i = 0; i < ch2.length; i++) {
			ch3[ch1.length + i - 1] = ch2[i];
		}
		return ch3;
	}

	private static void printChars(char[] ch) {
		for (int i = 0; i < ch.length; i++) {
			System.out.print(ch[i]);
		}
		System.out.println();
	}
}

public class TakeOutVowels {
	public static void main(String[] args) {
		// 待输入的字符串
		String str = "helloWorld+aeiou";
		// 元音字典
		char[] vowels = { 'a', 'e', 'i', 'o', 'u' };
		char[] strCh = str.toCharArray();

		char[] vowelsBuffer = vowel(vowels, strCh);
		printChars(vowelsBuffer);
	}

	private static char[] vowel(char[] vowels, char[] strCh) {
		int k = 0;
		char[] vowelsBuffer = new char[200];
		for (int i = 0; i < strCh.length; i++) {
			for (int j = 0; j < vowels.length; j++) {
				if (strCh[i] == vowels[j]) {
//					System.out.print("(" + i + "," + strCh[i] + ")");
					if (k < 200)
						vowelsBuffer[k++] = strCh[i];
					else {
						System.out.println("内存已满");
						k = 0;
					}
				}
			}
		}
		return vowelsBuffer;
	}

	private static void printChars(char[] ch) {
		for (int i = 0; i < ch.length; i++) {
			System.out.print(ch[i]);
		}
		System.out.println();
	}
}

public class FindLongestWord {

	public static void main(String[] args) {
		String[] strs = { "i", "like", "chinese", "NiceToMeetYouToo", "helloworld", "NiceToMeetYou" };
		int longestIndex = findLongestWordIndex(strs);
		System.out.println("最长的单词为" + strs[longestIndex]);
	}

	private static int findLongestWordIndex(String[] strs) {
		int[] strLengths = new int[strs.length];
		// 最长的单词的下标
		int longestWordIndex = 0;
		for (int i = 0; i < strLengths.length; i++) {
			// 如果当前的单词比最长的单词还要长
			if (strs[i].length() > strs[longestWordIndex].length()) {
				// 那么认为当前这个单词是最长的
				longestWordIndex = i;
			}
		}
		return longestWordIndex;
	}
}

public class Encoding {

	public static void main(String[] args) {
		String str = "abcdefg";
		str = "abcdefghijklmnopqrstuvwxyz";
		str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
		str = "0123456789";
		str = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

		int key = 2;
		key = 3;

		
		char[] coded = shiftCoding(str, key);

		System.out.println(String.valueOf(coded));
		
		
		
		// printAsciiCodeSequence('a', 26, "'", "'", ",");
		// printAsciiCodeSequence('A', 26, "'", "'", ",");
		// printAsciiCodeSequence('0', 10, ",");
		// printAsciiCodeSequence('0', 10, "'", "'", ",");

		// printAsciiCodeSequence('a', 26);
		// printAsciiCodeSequence('A', 26);
		// printAsciiCodeSequence('0', 10);
	}

	/**
	 * 移位编码，讲一个单词在字母表中后移n位或者前移n位实现编码
	 * 
	 * @param str 需要编码的字符串(只支持大小写加数字)
	 * @param key 需要移动的位数
	 */
	private static char[] shiftCoding(String str, int key) {
		char[] lowerCaseLetters = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q',
				'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z' };
		char[] upperCaseLetters = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q',
				'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' };
		char[] numbers = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
		char[] strs = str.toCharArray();
		char[] coded = new char[strs.length];

		for (int i = 0; i < strs.length; i++) {
			if (strs[i] >= 'a' && strs[i] <= 'z') {
				if (strs[i] + key > 'z') {
					// System.out.print((char) (strs[i] + key - 26));
					coded[i] = (char) (strs[i] + key - 26);
				} else {
//					System.out.print((char) (strs[i] + key));
					coded[i] = (char) (strs[i] + key);
				}
			}
			if (strs[i] >= 'A' && strs[i] <= 'Z') {
				if (strs[i] + key > 'Z') {
					// System.out.print((char) (strs[i] + key - 26));
					coded[i] = (char) (strs[i] + key - 26);
				} else {
					// System.out.print((char) (strs[i] + key));
					coded[i] = (char) (strs[i] + key);
				}
			}
			if (strs[i] >= '0' && strs[i] <= '9') {
				if (strs[i] + key > '9') {
					// System.out.print((char) (strs[i] + key - 10));
					coded[i] = (char) (strs[i] + key - 10);
				} else {
					// System.out.print((char) (strs[i] + key));
					coded[i] = (char) (strs[i] + key);
				}
			}
		}
		return coded;
	}

	/**
	 * 打印连续的ASCII码
	 * 
	 * @param firstASCII 刚开始的ASCII码
	 * @param times 要排在firstASCII之后多少位的ASCII
	 * @param head 打印在 ASCII码 前面的字符串
	 * @param tail 打印在ASCII码 之后的字符串
	 * @param delimiter 分隔符
	 */
	private static void printAsciiCodeSequence(char firstASCII, int times, String head, String tail, String delimiter) {
		for (int i = 0; i < times; i++) {
			if (i > 0)
				System.out.print(delimiter);
			System.out.print(head + (char) (firstASCII + i) + tail);
		}
		System.out.println();
	}
	/**
	 * 连续打印ASCII字符序列
	 * @param firstASCII 要打印的ASCII字符的开始字符
	 * @param times 要打印的ASCII字符序列的长度
	 */
	private static void printAsciiCodeSequence(char firstASCII, int times) {
		printAsciiCodeSequence(firstASCII, times, "", "", "");
	}

	private static void printAsciiCodeSequence(char firstASCII, int times, String delimiter) {
		printAsciiCodeSequence(firstASCII, times, "", "", delimiter);
	}
}