Java编程思想查漏补缺（二）

之前学C++多一点，现在转做数据行业，因此开始学习Python和Java。阅读Java编程思想第五版时，发现自己在Java方面的一些不足，记录，共享之。本人基本是利用碎片时间，以及晚上睡不着的时候用手机在WPS上看的PDF版本，若有错误之处，还望指出，有错必改。

看到第六章，有不少东西和C++不太一样了。

2016-06-27
1. static
1.1 静态方法
通常, 在一个类中定义一个方法为static, 那就是说, 无需本类的对象, 使用类名即可调用该方法静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法 (就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！
static方法有以下几条限制：
1) static方法中仅能调用static方法, static变量。因为非static方法, 非static变量仅能使用对象调用(或者说this)。而static方法本身没有this。而通过在static内部new上一个对象, 这样是无意义的, 出了函数
2) 不和this, super沾边

1.2 静态变量
全局的生命周期, 局部的作用范围。静态变量与静态方法类似。静态变量只初始化一次, 其后的均为赋值。按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是： 
对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。 对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。

1.3 静态类
通常一个普通类不允许声明为静态的, 只有一个内部类可以。这时这个声明为静态的内部类可以直接作为一个普通类来使用, 而不需要实例一个外部类。

class OuterClass {
	public static class InnerClass {
		InnerClass() {
			System.out.println("InnerClass");
		}
	}
}

public class Exp {
	public static void main(String[] args) {
		OuterClass.InnerClass inner = new OuterClass.InnerClass();
	}
}

2. 数组相互赋值

int[] array1 = new int[] { 1, 2, 3 };
int[] array2;

array2 = array1;

3. 可变参数
3.1 使用数组来接受
3.2 使用...来代替数组

Object...args; int...args，表示不管有多少个符合类型的参数都被放入args中:

class A {}

public class Exp {
	static void printArray(Object[] args) {
		for(Object obj: args) {
			System.out.println(obj + " ");
		}
		System.out.println();
	}
	
	static void printArray(boolean flag, Object...args) {
		if(flag == true) {
			for(Object o: args) {
				System.out.println(o);
			}
		}
		System.out.println();
	}
	
	public static void main(String[] args) {
		printArray(new Object[] {new Integer(47), new Float(3.14)});
		printArray(new Object[] {"Unique", "Z_"});
		printArray(new Object[] {new A(), new A()});
		
		// Object类是一切类的基类, 可以使用基本数据类型 
		printArray(new Integer[] {99, 100});
		printArray(new Object[] {99, 100});
		
		
		printArray(true, new Object[] {new Integer(47), new Float(3.14)});
		printArray(true, new Object[] {"Unique", "Z_"});
		printArray(true, new Object[] {new A(), new A()});
		printArray(true, new Object[] {99, 100});
	}
}

4. enum

enum就是一个类。疑点：this的使用？什么时候可以省略？为什么在main中只能使用Spiciness.MILD，若有人知道还望不吝指出。

enum Spiciness {NOT, MILD, MEDIUM, HOT, FLAMING};

public class Exp {
	Spiciness degree;
	
	public Exp(Spiciness degree) {
		this.degree = degree;
	}
	
	// enum + switch
	public void describe() {
		switch(this.degree) {
			case NOT:
				System.out.println("Not at all.");
				break;
			case MILD:
				System.out.println("very good.");
				break;
			case MEDIUM:
				System.out.println("A little hot.");
				break;
			case HOT:
				System.out.println("Hot.");
				break;
			case FLAMING:
				System.out.println("Very hot.");
				break;
			default:
				System.out.println("The degree not founded.");
		}
	}
	
	// 遍历enum
	public void ergodicEnum() {
		for(Spiciness s: Spiciness.values()) {
			System.out.println(s);
			System.out.println(s.ordinal());
		}
	}
	
	public static void main(String[] args) {
		// Exp exp = new Exp(degree.MILD);
		
		Exp exp = new Exp(Spiciness.MILD);
		exp.describe();
		exp.ergodicEnum();
	}
}

2017-6-28
1. package
Java的一个package就是一个类库单元, 一个包, 包内包含一组类。这个包可以说就是文件夹名。src是存源码的地方, src下面一级就是包, 比如eclipse中的(default package), 比如src/fruit/ Apple.java, Pear.java在Apple.java和Pear.java的首行都放入: package fruit, 表示Apple.java, Pear.java被组织在包fruit下面。要想使用这两个Java文件, 则必须: import fruit.*;

2. Java访问权限修饰词
2.1 包访问权限
不使用任何关键词时, 为默认访问权限 - 包访问权限(能在当前包内访问)

2.2 取得对类中某成员的访问权的唯一途径是:
2.2.1 使该成员成为public, 于是无论是谁, 无论在哪里, 都可以访问该成员。
2.2.2 通过不加访问权限修饰词, 并将其他类放置于同一个包内的方式给成员赋予包访问权限, 这样包内的每个类都能访问这个成员了。
2.2.3 通过继承技术, 子类能够访问基类的 public, protected
2.2.4 提供访问器(accessor)和变异器(mutator)方法, 也称为get / set方法。对于oop而言, 这是最优雅的方式。

2.3 private
除了包含该成员的类之外, 其他任何类都不能访问这个成员。任何可以肯定只是该类的一个助手的方法, 都可以将它指定为 private

class Sundae {
	
	private Sundae() { }
	
	static Sundae makeASundae() {
		// 不能通过调用构造器来创建对象, 而必须调用该方法来达到此目的
		return new Sundae();
	}
}

public class IceCream {
	
	public static void main(String[] args) {
		Sundae sundae = Sundae.makeASundae();
	}
}

3. protected

关键字protected处理的是继承的概念

package dessert;
public class Cookies {
	
	public Cookies() {
		System.out.println("Cookie constructor");
	}
	
	protected void bite() {
		System.out.println("bite");
	}
}

import dessert.Cookies;
public class ChocolateChip extends Cookies {
	
	public ChocolateChip() {
		System.out.println("ChocolateChip constructor");
	}
	
	public void chomp() {
		bite();
	}
	
	public static void main(String[] args) {
		ChocolateChip chip = new ChocolateChip();
		
		chip.chomp();
	}
}
输出是:
Cookie constructor
ChocolateChip constructor
bite