• 一个源文件中只能有一个声明为public的类，同时要求此类的类名与源文件名一致。
• 关键字：被java赋予特殊含义的单词，都是小写 。例如：class
• 标识符：变量，方法，类等要素命名时使用的字符序列称为标识符。规则(字符，数字，下划线，$，但是不能数字开头)

• 数组
  • char类型默认值是空格
  • float/double默认值是0.0
  • boolean默认值是false
  • int long byte short 默认是0
  • 对于引用数据类型的变量，默认值是null(例如null)
• 内存分析
  • 栈
    • 局部变量
    • 对象的引用
  • 堆
    • new出来东西(例如对象，数组)
  • 方法区
    • 方法/类/包等等的定义
    • 字符串的常量池
  • 静态域
    • static修饰
• 数组排序算法
  • 冒泡排序
  • 直接选择排序

面向对象

- 成员变量：声明在类里，方法外(有默认值，有public,private,protected,缺省值共四种修饰符，存在于堆空间中)
- 局部变量：方法内部的变量，代码块内部，形参(局部变量不能有修饰符，与所在方法修饰符相同)(必须初始化赋值，存在与栈空间中)
- 属性：类中的成员变量
- 行为：类中的成员方法

• 重载

  • 方法名相同
  • 同一个类中
  • 方法参数列表不同(个数或类型不同)
  • 和方法返回值没关系

  public int getSum(int a,int b){
      return a+b;
  }
  public int getSum(int a,int b,int c){
      return a+b+c;
  }
  public double getSum(int a,int b,double c){
      return a+b+c;
  }
  

• 修饰符

  • private:类内部使用
  • 缺省值：类内部，同一个包
  • protected：类内部，同一个包，字类
  • public:全部可用

• 构造器

  • 修饰符 类名(){}

  class B {
      public int age;
      public String name;
      public B(int age) {
          this.age=age;
      }
  
      public B(int age, String name) {
          this(age);
          this.name=name;
      }
  }
  说明：this指向最终调用者，此处有构造函数的重载，this(age)调用的是
  第一个构造函数，且this()方式调用其他重载的构造函数的时候，必须在构造
  函数的第一行。
  

• 继承

  • 子类可以获得父类中声明的属性，方法。
  • 父类中私有的属性和方法，字类同样可以获得，只是因为封装性，所以不能直接调用罢了，但是可以使用get,set等间接方式使用。
  • 方法的重写
    • 有继承关系
    • 子父类有相同方法(返回值，方法名，参数列表必须相同)
    • 子类方法修饰符不能小于父类修饰符
  • 多态性(编译看左边，运行看右边)
    • 要有类的继承
    • 要有子类对父类方法的重写
    • 所以父类对象是不能调用子类的特有方法的(不是重载的方法)，因为编译期都过不去，父类没有该方法
    • 如果针对上一条，强制运行，可以让父类对象向下转型为子类，这样就可以调用了
    • 子类对象的多态性，并不适用于属性

  public class A {
  
  /**
   * @param args
   */
  public static void main(String[] args) {
      // TODO Auto-generated method stub
      A a=new B();
      a.getSum();
      B b= (B) a;
      b.test();
      //子类的属性不存在多态
      System.out.println(b.num+"..."+a.num);//101    100
  }
  
  public void getSum() {
      System.out.println("父类");
      }
  }
  class B extends A{
      public void getSum() {
          System.out.println("子类");
      }
      public void test() {
          System.out.println("特有方法");
      }
  }
  

• ==

  • 基本数据类型
    • 根据基本数据类型的值进行转换比较
    • 两边类型不同，向精确度更高的转换(例如 56=='A' true)
  • 引用数据类型
    • 比较地址是否相同

• equal

  • 是Object的方法，所有对象都有
  • 因为来源于Object，所以不能用于基本数据类型比较

• String

  • 针对string的==比较的是地址
  • 针对string的equal比较的是内容

  • 针对string都是存放在方法区的字符串常量池中的，所以不论是String a="AA",还是String b=new String("AA"),最终的"AA"对应地址都是同一个；之所以a==b结果是false，是因为，a在栈中指向的是"AA"真实地址，但是b指向的是堆里面new String("AA")的地址,而堆内部对应的地址才指向"AA".

    
    

    

• toString

  • 打印一个对象时候，默认调用就是这个对象的toString方法(sys=>p等效于sys=>p.toString())

  • 如果对象所在类没有重写对应的toString方法，则调用就是Object的toString方法,输出是地址。

    
    

    

• 单元测试步骤：

  • 右键项目，选中build path
  • 选中add libiaries
  • 在弹出窗选择junit,然后选择对应版本的junit版本
  • 在主类(就相当于测试基础类,可以是任意类。)可以编写写测试代码(无参数无返回值的方法)
  • 在测试方法上面添加@Test的注解(需要导test入包)
  • 鼠标双击方法名，run as =>junit test

  • 如果绿色标志证明运行正常，否则程序有错误

    
    

    

• static
  static修饰属性：
  - 由类创建的所有对象，都公用这一个属性
  - 类变量存在于静态域中

  • static修饰方法(类方法)：
    • 随着类的加载而加载，在内存中也是独一份
    • 类.类方法调用
    • 因为最先加载，所以只可以使用静态的属性和方法，不能使用实例方法和属性(此时还没随类加载)
    • 静态方法里面不可以有this/super

• 单例模式(一个类只能存在一个实例对象)

  • 饿汉式

/**
 * 饿汉式：开发时候常用
 * 
 * @author Administrator
 * 
 */
class Singleton {
    private static Singleton sg = new Singleton();

    private Singleton() {

    }

    public static Singleton getSingle() {
        return sg;
    }
}

* 懒汉式

        /**
 * 懒汉式：可能存在线程安全问题
 * 
 * @author Administrator
 * 
 */
class Singleton {
    private static Singleton sg;

    private Singleton() {

    }

    public static Singleton getSingle() {
        if (sg == null) {
            sg = new Singleton();
        }
        return sg;
    }
}

• final
  • final修饰的类不能被继承
  • final修饰方法不能被重写
  • final修饰属性，此属性就是一个常量，常量必须显式赋值(没有默认值，赋值时间只要是对象初始化之前即可)
  • 如果static final修饰属性，说明该属性是全局常量

public class INClass{
   void innerClass(final String str){
        class IClass{
            IClass(){
                System.out.println(str);
            }
        }
        IClass ic=new IClass();
    }
  public static void main(String[] args){
      INClass inc=new INClass();
      inc.innerClass("Hello");
  }
}
说明：final修饰str，否则方法执行完毕会释放str，但是此时内部类还需要使用str。
所以利用final修饰避免释放保证内部类使用正常。此处java的内存回收应该不是引用计数，
否则不会出现这种情况，具体后期研究。

抽象类

• abstract修饰类:抽象类
  • 不可以被实例化
  • 抽象类有构造器(凡是类都有构造器)
  • 抽象类中可以没有抽象方法
  • 抽象类中可以存在抽象方法和实例方法
• abstract修饰的方法：抽象方法
  • 没有方法体(public abstract eat();)
  • 抽象方法只保留方法的功能，具体的执行，交给继承抽象类的子类，由子类重写此抽象方法。
  • 抽象方法所在类必须是抽象类
  • 子类继承抽象类，实现全部抽象方法，则子类就是实体类可以实例化，否则此类也是抽象类
• 模板方法设计模式

public class D {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //下面两种等效
//      ABTemplate ab=new Template();
        Template ab=new Template();
        ab.getTime();
    }

}
abstract class ABTemplate{
    public abstract void code();
    public void getTime() {
        long t1=System.currentTimeMillis();
        this.code();
        long t2=System.currentTimeMillis();
        System.out.println(t2-t1);
    }
}
class Template extends ABTemplate{

    @Override
    public void code() {
        int total=0;
        for (int i = 0; i < 1000; i++) {
            total+=i;
        }
        System.out.println(total);
    }
}
说明：这样形式就可以实现一部分固定，一部分子类实现。

接口

• 接口是抽象方法和常量值的定义的集合。
• 本质上：接口是特殊的抽象类
• 接口可以多实现
• 接口针对功能
• 接口没有构造器
• 接口之间可以继承(而且可以多继承)
• 接口和实现类之间也符合多态性

public interface One {
    //接口中只能放常量，所以即使不加public static final修饰，默认也会加上
    public static final int num=0;
    String info="测试";
    //接口中只能有抽象方法，所以下面两者等效，默认加上public abstract修饰
    public abstract void test();
    void getName();
}
class BB implements One{

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

    public void getName() {
        System.out.println(info);
    }
    
}

• 工厂方法模式

public class FactoryTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        WorkFactory wf=new StudentWorkFactory();
        wf.getWork().doWork();//学生写作业
        WorkFactory wf1=new TeacherWorkFactory();
        wf1.getWork().doWork();//老师批改作业
    }

}

interface WorkFactory{
    Work getWork();
}
class StudentWorkFactory implements WorkFactory{

    public Work getWork() {
        return new StudentWork();
    }
    
}
class TeacherWorkFactory implements WorkFactory{

    public Work getWork() {
        return new TeacherWork();
    }
    
}
interface Work{
    void doWork();
}
class StudentWork implements Work{

    public void doWork() {
        System.out.println("学生写作业");
    }
}
class TeacherWork implements Work{

    public void doWork() {
        System.out.println("老师批改作业");
    }
}

• 静态代理模式

public class TestProxy {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Object b=new Px1();
        b.action();
    }

}
interface Object{
  void  action();
}
class Px1 implements Object{
    Px2 p2;
    public Px1() {
        p2=new Px2();
    }

    public void action() {
        System.out.println("代理执行开始");
        p2.action();
        System.out.println("代理执行结束");
    }
}
class Px2 implements Object{

    public void action() {
        System.out.println("被代理执行开始");
        System.out.println("被代理执行结束");
    }
}
输出：
代理执行开始
被代理执行开始
被代理执行结束
代理执行结束

内部类

• 成员内部类(类里方法外)
• 局部内部类(类的方法里)

匿名内部类
public class InnerClass {

    /**
     * @param args
     */
    public static void main(String[] args) {
        InnerClass ic=new InnerClass();
        ic.show(new Imple() {
            public void test() {
                System.out.println("测试");
            }
        });
    }
    public  void show(Imple p) {
        p.test();
    }
    
    interface Imple{
        void test();
    }
}