Java基础

基本类型

Java支持的类型分为两类：基本类型和引用类型。
Java的基本类型分为两类，布尔类型和数值类型。又细分为整数类型、浮点数类型、布尔类型和字符类型。
整型(整数类型)按照值域从小到大分为byte、short、int、long。
字符型使用单引号，使用unicode字符集作为编码方式(支持世界上所有书面语言的字符)。字符串则是引用类型（由String类构造）。
浮点型分成float和double。
Java的所有数值型变量可以相互转换，范围小的可以自动向范围大的转换，反之则需要强制转换。(int a = (int)xxx)
当做连接运算的时候(“xx” + 基本类型)，基本类型都会转换成字符串类型。

包装类

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的。
Java中的包装器类有两个主要的目的：

• 提供一种机制，将基本值“包装”到对象中，从而使基本值能够包含在为对象而保留的操作中，比如添加到Collections 中，或者从带对象返回值的方法中返回（List是无法使用的）
• 为基本值提供分类功能。这些功能大多数于各种转换有关：在基本值和String对象间相互转换，在基本值和String对象之间按不同基数转换，如二进制、八进制和十六进制。

int i = 100;

这个过程中会自动根据数值创建对应的 Integer对象，这就是装箱。

Integer i = 10; //装箱
int index = i;  //拆箱

装箱就是自动将基本数据类型转换为包装器类型；拆箱就是自动将包装器类型转换为基本数据类型。在装箱的时候自动调用的是Integer的valueOf(int)方法。而在拆箱的时候自动调用的是Integer的intValue方法。

引用类型

当我们把对象赋值给一个变量的时候，不会在内存中把对象再复制一遍，只会存一份引用变量，让引用变量指向对象。
null是任何引用类型的默认值。

面向对象

当类只是完成某个功能，并不需要在内存中保存对象的状态，这时候可以考虑类的静态方法。可以直接使用类.方法来调用。
当一个对象的方法中调用了其他方法，this可以省略。
成员变量是指在类中定义的变量，局部变量则是在方法中定义的变量。成员变量分为类变量(static静态变量)和实例变量(在对象上)。
将变量定义在for循环中

   for(int i = 0; i < 10; i++) {
      // 属于循环代码块中，为循环体内部变量
   }

包

package的存在是为了唯一表示一个包，开辟命名空间

instanceof

当a instanceof A 返回true的时候，代表a是A类/A接口/A类的子类的实例。null instanceof xxx永远返回false。

成员变量使用接口型

成员变量使用接口型，也可以使用类的实例变量

	public interface TestFace {
	   //定义一个接口方法
	   void make();
	}
	public class MyClass {
		//定义一个接口型变量tf
	    TestFace tf;
	    //构造函数初始化接口型变量tf
	    public MyClass(TestFace tf) {
	       this.tf = tf;
	    }
	    public work() {  
		   //实际的接口型类实例
	       this.tf.make();
	    }
	}
	public class C1 implements TestFace {
		//实现接口的方法make
	    public void make() {
	       System.out.println("c1");//打印c1
	    }
	}
	public class C2 implements TestFace {
		//实现接口的方法make
	    public void make() {
	       System.out.println("c2");//打印c2
	    }
	}

	TestFace tf1 = new C1();//实现一个类实例C1
	TestFace tf2 = new C2();//实现一个类实例C2
	MyClass mc = MyClass(tf1);//定义一个MyClass的类实例，使用tf1
	MyClass mc2 = MyClass(tf2);//定义一个MyClass的类实例，使用tf1
	同一个类的work，能够实现不同的打印内容
	mc.work();
	mc2.work();

继承和组合

继承让子类可以复用父类A的public方法，而组合则是将A类对象作为新类的成员变量组合进来，用来使用A类的功能。继承是对已有的类做一番改造，以获得一个新版本。组合则是对两个不同功能的类进行组合使用。

==和equals方法

当判断基本变量时，使用==运算符。
当判断引用类型时，只有指向同一个对象时，==才会返回true。
equals常由类自己实现。

final成员变量

final修饰的成员变量需要显式指定初始值，指定之后不能再被重新赋值，相当于常量。

抽象类和接口区别

接口和抽象类都不能被实例化。
门的开关方法为门的特有属性，而门上装一个警报器则可以通过接口实现。接口用来描述一种非自身主功能的规范。

   public interface Alarm() { 
	   void alarm();
   } 
   abstract class Door {
	    public abstract void open();
	    public abstract void close();
   }
   public alarmDoor extends Door implements Alarm {
	   void oepn() {
	      //....
	    }
	    void close() {
	      //....
	    }
	    void alarm() {
	      //....
	    }
   }

简单工厂模式

如果把Print类在Computer类中组合，当把Print类替换成BetterPrint的时候就要将Computer类中的Print进行修改。如果有多个类组合Print的时候，工作量就会很大。此时将Print类包一层变成OutputFactory生产的对象再传进来，相当于Computer只获取Print工厂批量产生的对象，解除和Print对象的耦合。

	public class Computer {
		private Output out;
		public Computer(Output out) {
			this.out = out;
		}
		// 定义一个模拟字符串输入的方法
		public void keyIn(String msg) {
			out.getData(msg);
		}
		// 定义一个模拟打印的方法
		public void print() {
			out.out();
		}
	}
	public class OutputFactory {
		public Output getOutput() {
			return new Printer();
		}
		public static void main(String[] args) {
			OutputFactory of = new OutputFactory();
			// 将Output对象传给computer
			computer c = new Computer(of.getOutput());
			c.keyIn("sysuzhyupeng");
			c.print();
		}
	}

命令模式

将实现了命令接口的对象传入处理器中，即可在主类的process方法中调用命令的process方法。命令具体内容和执行命令的流程就分开了，命令的具体内容可以到调用时才确定。

    public interface Command {
        // process方法用来封装处理行为
	    void process(int[] target);
    }
    public class ProcessArray {
        public void process(int[] target, Command cmd) {
	        cmd.process(target);
        }
    }
    public class CommandTest {
	    public static void main(String[] args) {
		    ProcessArray pa = new ProcessArray();
		    int[] target = { 2, 1, 3, 4 };
		    // PrintCommand和AddCommand都是实现了Command接口的对象
		    pa.process(target, new PrintCommand());
		    pa.process(target, new AddCommand());
	    }
    }