张孝祥java笔记(1-16)

------/6代码模板
输入syso即出现System.out.println();因java、editor、templates
选中、右键surround with、try/catch block
------/8静态导入
Import导入一个类或某个包下所有类
Import static导入一个类的某个静态方法或所有静态方法
System.out.println(Math.max(3,6));
System.out.println(Math.abs(3-6)); //类的静态方法
若多次使用，则每回都加Math类名很麻烦：
//import static java.lang.Math.max; //导入Math类下max静态方法
import static java.lang.Math.*; //导入Math类下所有静态方法
System.out.println(max(3,6)); //不再加前缀
System.out.println(abs(3-6));
------/9可变参数

class Person{
	void eat(){
		System.out.println("Person eat");
	}
}
class Student extends Person{
	void print(){
		super.eat();
		System.out.println("Student eat");
	}
}
		Student stu=new Student();
		stu.print();

结果：
Person eat
Student eat
若Person中eat为private，则Student中eat非复写，为全新方法，super.eat()报错
可变参数：
出现在参数列表最后、…位于变量类型和变量名之间，前后有无空格都ok，方法体内以数组形式访问可变参数

public class Test {
	public static void main(String[] args){
		System.out.println(add(1, 1, 2, 3));	//静态直接调用，选中alt+/
	}
	static int add(int x,int...args){
		int sum=x;
		for (int i = 0; i < args.length; i++) {
			sum+=args[i];
		}
		return sum;
	}
}

------/10 for循环增强
语法：for(type 变量名：变量集合){}
变量集合可为数组

	static int add(int...args){
		int sum=0;
		for(int arg:args){
			sum+=arg;
		}
		return sum;
	}

------/11 基本数据类型自动装箱和拆箱
int i=1;
Integer integer=Integer.valueOf(i); //返回指定 int值的Integer实例
System.out.println(integer.intValue()); //以 int类型返回该 Integer的值、1
Integer类型的对象包含一int类型的字段
Integer integer=1; //自动装箱：基本数据类型封装成Integer对象赋给integer引用
System.out.println(integer+1); //自动拆箱(Integer对象不支持加法)、2
== 判断俩引用是否指向同一对象
Integer i1=1;
Integer i2=1;
Integer i3=2;
System.out.println(i1==i2); //装箱，装出是否为同一对象？
System.out.println(i1==i3);
Integer i4=128; //装箱成Integer对象
Integer i5=128;
System.out.println(i4==i5);
结果：
true //同一个
false
false
一字节内-128~127，装箱成Integer对象后将其缓存，下次再需…直接指向该对象，节省空间时间(因数小频繁使用，若每次都装箱成一新对象，则产生很多)
享元模式flyweight：如word每字符是一对象，则产生无数对象，可仅生成26个对象，为每对象提供display(int x,int y)方法，同理如桌面图标
------/13 基本类模拟枚举
枚举：让某类型变量的取值只能为若干固定值中的一个
枚举原理：
------/WeekDay.java

class WeekDay {
	private WeekDay(){	//private导致只能在该类内部生成对象
	}
	static final WeekDay SUN=new WeekDay();
	static final WeekDay MON=new WeekDay();
	WeekDay nextDay(){	//不能再为static
		if(this==SUN){	//大量if else麻烦
			return MON;
		}else{
			return SUN;
		}
	}
	String myToString(){
		return (this==SUN)?"SUN":"MON";
	}
}

------/Test.java

class Test {
	public static void main(String args[]){
		WeekDay wDay=WeekDay.MON;
		System.out.println(wDay.nextDay().myToString());
	}
}

结果：SUN
------/WeekDay.java另一实现

abstract class WeekDay {
	private WeekDay(){	//private导致只能在该类内部生成对象
	}
	static final WeekDay SUN=new WeekDay(){	//该法很经典
		WeekDay nextDay() {
			return MON;
		}
	};
	static final WeekDay MON=new WeekDay(){
		WeekDay nextDay() {
			return SUN;
		}
	};
	abstract WeekDay nextDay();
	String myToString(){
		return (this==SUN)?"SUN":"MON";
	}
}

------/14 枚举

class Test {
	public static void main(String args[]){
		WeekDay wDay=WeekDay.MON;
		System.out.println(wDay);	//自动调用toString方法
		System.out.println(wDay.ordinal());
		System.out.println(WeekDay.valueOf("SUN"));//静态方法，据SUN获得对应对象
		System.out.println(WeekDay.values().length);//返回对象数组
	}
	enum WeekDay{	//枚举相当于类，元素为该类对象
		SUN,MON,TUE,WED,THU,FRI,SAT;
	}
}

结果：
MON
1
SUN
7
------/15 带有构造函数的枚举

class Test {
	public static void main(String args[]){
		WeekDay weekDay=WeekDay.MON;
	}
	enum WeekDay{	//枚举也是个类
		SUN(),MON(1),TUE,WED,THU,FRI,SAT; //元素列表必须位于最前
		private WeekDay(){
			System.out.println("first");
		}
		private WeekDay(int i){
			System.out.println("second");
		}
	}
}

结果：
first
second
first
first
first
first
first
------/16 带有抽象方法的枚举

public enum TrafficLamp{
	RED(30){	//对象RED由TrafficLamp匿名子类实现
		TrafficLamp nextLamp(){	//调用父类有参构造函数
			return GREEN;
		}
	},
	GREEN(45){
		TrafficLamp nextLamp(){
			return YELLOW;
		}
	},
	YELLOW(5){
		TrafficLamp nextLamp(){
			return RED;
		}
	};
	abstract TrafficLamp nextLamp();
	private int time;
	private TrafficLamp(int time){
		this.time = time;
	}
}

编译后生成：Test$TrafficLamp$1.class、..
枚举只有一个成员，可作为单例的一种实现方式
------/

abstract public class Person{
	int age;
	Person(int age){
		this.age=age;
	}
	abstract void Print();
}
class Test {
	public static void main(String args[]){
		new Person(26) {	//子类调用父类有参构造函数
			void Print() {
				System.out.println(age);
			}
		}.Print();		//26
	}
}