Java基础详解编程语言

基本类型

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

引用类型

当我们把对象赋值给一个变量的时候，不会在内存中把对象再复制一遍，只会存一份引用变量，让引用变量指向对象。
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()); 
        } 
    }