Java基础整理（一）

成熟的人不问过去，聪明的人不问现在，豁达的人不问未来
应该让自己忙着做些什么才能够开心！ —— LB Zhang

---

1. 编程基础

1.Java开发包的种类：JavaEE(企业级),JavaME(移动),JavaSE(标准)
2.Java语言的特性：简单的程序设计语言。 面向对象、分布式、健壮、安全、跨平台、多线程
3.命名Java变量: 包、类、成员、方法、常量
4.理解成员: 成员变量有初始值，局部变量没有。 实例成员：对象是以类为蓝本创建的类的实例。在类中一般定义了类的成员（变量和方法）,所以实例变量包括实例变量和实例方法，在创建类的对象时，对象会拥有类中所定义的变量的副本，对象的变量也称为实例变量。对象的方法定义了该对象的行为，一般称为实例方法。实例的方法属于类的每个对象,而方法的实现是所有类的实例共享的。属于对象的实例变量和实例方法合称为实例成员。
静态成员：静态成员隶属于类，而不属于任何类生成的对象，当类加载时就会初始化静态变量；同样，静态方法也是隶属于类的，而不是对象。静态变量和静态方法称为静态成员。静态成员只属于类。
5.Java中，对象是如何传递消息:Java对象通过调用彼此的消息传递，是通过调用相互的实例方法来实现的，而不是静态方法。

6.类的静态变量的理解：静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。
7.UML建模表示图多种，继承使用一个空心三角来表示，方向是子类指向父类的，表明子类依赖父类。private属性不能继承。

8.Java开发的原则：【1】Java中的代码必须封装在类中；【2】Java中有两种值：对象的引用和元数据类型值【3】引用代表根据类的创建【4】对象只能通过引用加以操作【5】Java中的对象不能包含其他的对象，对象只能拥有指向其他对象的引用.

2. 语言基础

/**
 * Java语言基础
 */
/**
 * @author MrLBZ
 * 1. String 和 StringBuffer的区别：Java提供了两个字符串类，String和StringBudder 。他们可以储存和操作字符串，即包含多个
 * 字符的字符串数据。String提供了值不可变的字符串，StringBuffer类提供了字符串可以进行修改。当知道字符数据要改变的时候，就可以
 * 使用StringBuffer类创建，典型的，可以使用StringBuffer来动态的构造字符串。
 * 2.  
 * 
 */

package ic.lbz.ch02;
/** 
 * @author LbZhang
 * @version 创建时间：2016年5月26日 上午10:44:39 
 * @description Java标识符
 * Java的标识符可以由一系列的字符，每个字符可以是字母、数字和_以及货币符。
 * 注意：Java标识符的第一个字母不能是数字，Java语言是区分大小写的。中文变量和中文字符是合法的。
 */
public class JavaSign {

    //public int 48abc = 20;
    private int Num=100;
    //private int m-48abc;
    private int m_abc=30;
    private int number=60;
    private String $hk;
    private String 我的变量="我是yigebing";
    private double ￥money = 22.00;
    //private String my@email = "hello";

    public static void main(String[] args) {
        JavaSign js = new JavaSign();
        System.out.println(js.get我的变量());
    }

    public int getNum() {
        return Num;
    }

    public void setNum(int num) {
        Num = num;
    }

    public int getM_abc() {
        return m_abc;
    }

    public void setM_abc(int m_abc) {
        this.m_abc = m_abc;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public String get$hk() {
        return $hk;
    }

    public void set$hk(String $hk) {
        this.$hk = $hk;
    }

    public String get我的变量() {
        return 我的变量;
    }

    public void set我的变量(String 我的变量) {
        this.我的变量 = 我的变量;
    }

    public double get￥money() {
        return ￥money;
    }

    public void set￥money(double ￥money) {
        this.￥money = ￥money;
    }


}

package ic.lbz.ch02;
/** 
 * @author LbZhang
 * @version 创建时间：2016年5月26日 上午11:07:37 
 * @description Java关键字
 * 
 */
public class JavaKey {

    private int java=100;
    public String True = "Myjava";

    public static void main(String[] args) {
        int integer = 20;
        JavaKey key = new JavaKey();
        System.out.println(key.java);

    }

    /* //这是一个有效注释 */
}

package ic.lbz.ch02;
/** 
 * @author LbZhang
 * @version 创建时间：2016年5月26日 下午7:45:10 
 * @description 变量初始化
 */
public class TestVariableInit {
    public static void main(String[] args) {

        TestClass tc = new TestClass();
        //int j;
        int j=0;
        System.out.println(tc.str);
        System.out.println(tc.i);
        System.out.println(j);//局部变量不会自动初始化


    }

}

class TestClass{
    int i;
    String str;
}

3. 运算符和类型转换

/**
 * 运算符和类型转换
 */
/**
 * @author MrLBZ
 *1. 位运算 ： 非 与 或 
 *2. equal和==的区别：【1】原始数据的比较：相等和不等运算符可以比较原始数据类型。不过在软件开发中需要注意浮点型的数值的比较，
 *看似相等其实可能不想等。【2】引用比较:equals在没有覆盖的时候和==一样比较引用，不过equal相比于==的特殊的地方是可以覆盖。
 *String就覆盖了equal方法。
 *3. 参数传递：Java参数传递是传值，只不过可以分为基本类型的传值和 引用值传值。
 *4. 数据类型转换：【1】低级到高级自动类型转换【2】高级到低级强制类型转换【3】包装类过渡类型能够转换
 *
 *
 */

package ic.lbz.ch03;

import java.text.DateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

import sun.util.calendar.Gregorian;

/** 
 * @author LbZhang
 * @version 创建时间：2016年5月26日 下午10:14:12 
 * @description 日期选择题
 * 
 */
public class DateTest {

    /**
     * Java统计从1970年1月1号起的毫秒数量来计算日期
     * @param args
     */
    public static void main(String[] args) {
        Date mydate = new Date(0);
        System.out.println(mydate);

        Date now = new Date();
        long nowLong = now.getTime();
        System.out.println(nowLong);

        DateFormat df = DateFormat.getDateInstance();
        String s = df.format(now);
        System.out.println(s);

        GregorianCalendar  gc = new GregorianCalendar(2016,Calendar.APRIL,36);
        Date dt = gc.getTime();
        String ss = df.format(dt);

        System.out.println(ss);

    }


}

4. 访问控制

/**
 * 声明和访问控制
 * 1. 数组声明： 多维数组必须从左到右的创建。
 * 
 * 2. 类的声明只能是public abstract final 而不能使private
 * 
 * 3. 非静态方法有一个this 的对象引用，但是该引用是不能被改变的
 * 
 * 4. Java中可以使用的修饰符
 * 类：abstract、static、public、protected、final
 * 方法：abstract、static、public、protected、private、synchronized(同步)、native(本地)、final
 * 成员变量：static、public、protected、private、transient(过渡)、volatile、final
 * 局部变量：final
 * 
 * 5.final finally finalize的区别
 * final用于声明属性、方法和类，分别表示属性不可变、方法不可覆盖、类不可继承
 * finally是异常处理语句结构的一部分，表示总是执行
 * finalize是object类的一个方法，在垃圾收集器执行的时候，会调用被回收的对象的此方法，可以覆盖此方法，提供垃圾收集时的其他资源的回收，例如关闭文件等。
 * 
 * 6. 包含抽象方法的一定是抽象类
 * 
 * 7. 构造器和普通方法
 * 【1】构造器是为了创建一个类的实例、方法是 执行Java代码
 * 【2】修饰符、返回值和命名不同：构造器可以有任何访问的修饰符，例如public、protected、private或者没有修饰符。不同于方法的是构造器不能够有下面的
 * 非访问性的修饰符：abstract final native static synchronized等
 * 返回类型也是比较重要的。方法能够返回void或者任何类型的值，构造器没有，也不需要。
 * 构造器和类使用相同的名字，多为名词，完全一致。方法通常用小写字母开始，多为动词。
 * 【3】this的用法：构造器中this必须在第一行；方法引用this只想执行方法的类型的实例，静态方法不能使用this，因为静态方法不属于类的实例。
 * 【4】super的用法：子类的方法可以使用super调用父类的方法，构造器中调用super是调用父类的构造器实例化加入到子类中。
 * 【5】编译器自动加入不带参数的构造器
 * 【6】继承：构造器是不能被继承的，在构造器中不能构造自己，会引起死循环。
 * 【7】构造方法的初始化顺序
 * 对象创建时的初始化顺序是:设置成员的默认初始值-》调用对象的构造方法（但是没有执行构造方法体）-》调用父类的构造方法-》使用初始化程序和初始化块初始化成员-》执行构造方法体
 * 注意：在编程中初始化顺序：父类静态变量-》子类静态变量-》父类非静态变量-》父类静态代码快-》父类构造函数-》子类非静态变量-》子类静态代码块-》子类构造函数。
 * 
 */
/**
 * @author MrLBZ
 *
 */
package ic.lbz.ch04;

package ic.lbz.ch04;
/** 
 * @author LbZhang
 * @version 创建时间：2016年5月27日 上午9:58:48 
 * @description 类说明
 */
public class MyClass {

    public static void main(String[] args) {
        int [][]a = new int[4][];
        int []aa[] = new int [4][];
        //int ii[] = new int[2] {1,2};//不要重复声明
        int i[] = new int[] {1,2};//
        //数组大小是通过初始化代码隐含给定的，在一个数组引用的声明中不需要指定数组的大小，数组的大小总是同数组的实例而不是
        //同数组的引用相关联的。

        //aa.length 表示数组的长度



    }

}