java06

JDK的安装：
1.    下载、安装
2.    配置环境变量
    a)    path：.;%JAVA_HOME%in; 
    b)    JAVA_HOME：JDK的安装目录
    c)    classpath

JDK和JRE和JVM: 开发java要jdk,运行class文件要jre.

JAVA程序运行过程：
    1.    编译javac ：把java源文件编译成class字节码文件
    2.    运行java ：运行class文件


标识符(给类、方法、变量起名)：
    1.    以字母(采用Unicode字符集)、下划线、$ 开头    2.其余部分可以是：字母(采用Unicode字符集)、下划线、$、数字
    3.    不能为关键字

变量：
    1.    局部变量
        定义在方法内或语句块内。 从属于方法或语句块。
        使用之前，必须要手动初始化！
    2.    成员变量(实例变量 field) 
        定义在类里面、方法外面。   从属于对象！        如果我们没有手动初始化成员变量，系统会自动初始化。初始化的规则如下：
        数字：0,0.0   布尔：false  char:u0000   引用类型：null 
    3.    静态变量(类变量) 
        定义在类里面、方法外面、使用static修饰。  从属于类！        如果我们没有手动初始化静态变量，系统会自动初始化。初始化规则同成员变量。


数据类型：
1.    基本数据类型（3大类8小类）
    a)    数字
        i.    整数：byte(1个字节)  short(2个字节)   int(4个字节，整型常量默认该类型)   long(8个字节) 
        ii.    浮点数：float(4个字节)  double(8个字节，浮点常量默认为该类型)
    b)    字符 char(2个字节)
    c)    布尔  boolean(1位)
2.    引用类型(4个字节，堆的地址)
    a)    数组（数组也是对象）
    b)    对象
    c)    接口
3.    强制转型
    byte,short,char可以自动转为int,long转为int要强制转型。
    表达式中有类型的自动提升：    表达式中如果有long,结果就为long。表达式中如果有double,结果就为double。

运算符：
    1.    赋值运算符(=)
        if(b=true)  if(b)       if(c=3)  if(3==c)
    2.    算术运算符
    3.    关系运算符(==)
        常见错误写法： 1<a<3    1<a&&a<3
    4.    逻辑运算符
        &&, ||, !       3&&4(错误，要求左右两边为boolean型)
        &(按位与),|       3&4(正确)
    5.    位运算符
        &,|, <<（左移一位相当于乘以2）,>>>(右移一位相当于除以2)
        3*4(最快的方法是3左移2位)
    6.    扩展运算符
        +=,-=,*=,/=,%=
    7.    三目运算符
        (布尔表达式)?A:B

控制语句：
1.    顺序结构
2.    选择结构
    a)    If
    b)    If else
    c)    If else if … else 
    d)    switch  多值选择  表达式：int或char/short/byte, 枚举
    break问题
3.    循环结构
    a)    while  先判断后执行
    b)    for
    c)    do  while  先执行后判断
    break: 强制终止整个循环
    continue：结束本次循环，继续下一次！

面向对象基础：
1.    对象的进化史
a)    基本数据类型阶段       数据少     无数据管理时代
b)    数组                数据多了，将同类型的数据放到一起     弱管理
c)    结构体          数据多了，数据复杂了。将不同类型的数据放到一起    强管理
d)    对象    数据多了、类型复杂了、行为复杂了。将不同类型的数据放到一起 超强管理
对象和类：
对象是具体的，类是抽象的。  类也是一个模版，通过类这个模版我们也可以new
对象。

定义类：
public   class  类名  {
    //属性
    private  数据类型  属性名;   //建议增加相应的getter、setter方法
    //方法
    //构造方法
}

构造方法：
1.    方法名必须跟类名保持一致
2.    无返回类型
3.    通过new来调用
4.    无参构造器问题：
    a)    如果我们没有手动定义构造器，系统会自动为我们添加一个无参的构造器
    b)    如果我们自己定义了构造器，系统就不会为我们添加无参构造器
5.    构造方法的第一句总是:super，即调用直接父类的构造方法。
a)    有继承关系的构造方法调用的顺序

方法的重载(Overload)：
两同(同一个类、同一个方法名)三不同(参数列表不同：；类型、个数、顺序)
返回值不同，构成重载吗?  No
形参名称不同，构成重在吗?  No
this：
    普通方法中，调用本方法的对象。
    构造方法中，正要初始化的对象。
    还可以用来，调用其他的构造方法
super：
static：
    用它修饰的变量和方法，就变成了静态变量和静态方法。从属于类。通过类名即可调用。实际存储于方法区中。
package：
    package必须位于非注释行第一句。
    包名：域名倒着写
import：
    引入外部的类
Import  static(静态导入) :导入类的静态属性
final：    修饰变量：常量，只能赋值一次(命名规范：全部大写，多个单词之间通过下划线隔开)
    修饰方法：不能被重写
    修饰类： 不能被继承

面向对象的三大特征：
封装
    通过private、default 、protected、public关键字实现属性或方法的封装。
    “高内聚，低耦合”
继承
    通过extends 。两个好处：
1.    代码重用
2.    通过继承实现对现实世界更加准确的建模
    类只有单继承，没有像C++那样的多继承

    方法重写(Override)的要点：
    =：方法名保持一致
    >=: 子类的权限（private，public,protected）可以大于等于父类的。
    <=, <=: 子类的返回值类型小于等于父类的类型。 子类声明异常类型不能超过父类的类型。

Object类：
1.    是我们所有类的根基类
2.    toString
3.    equals、hashcode
4.    wait、notify、notifyAll
多态(polymorphism)
    三个必要条件：继承、方法的重写、父类引用指向子类对象
动态绑定、静态绑定：

抽象类：
1.    包含抽象方法（一定要被子类重写）的类，一定是抽象类。
2.    抽象类不能被new。
3.    抽象类可以包含：普通方法、成员变量、构造方法。

接口：
1.    interface
2.    类实现接口：implements    可以实现多个接口
3.    接口可以多继承
4.    接口定义的一组规范！实现现实世界中这样的逻辑：：如果你是…则必须能…

内存机制：
栈
1.    存放局部变量
2.    不可以被多个线程共享
3.    空间连续，速度快
堆
1.    存放对象
2.    可以被多个线程共享（每个对象都有锁）
3.    空间不连续，速度慢。但是灵活
方法区
1.    存放类的信息：代码、静态变量、字符串常量等
2.    可以被多个线程共享
3.    空间不连续，速度慢。但是灵活

垃圾回收器(GC   Garbage  Collection)：
1.    程序员不能调用垃圾回收器。但是可以通过System.gc()建议回收。
2.    finallize：一般也不用的调



栈内存：某一个函数被调用时，这个函数会在栈内存里面申请一片空间，以后在这个函数内部定义的变量，都会分配到这个函数所申请到的栈。当函数运行结束时，分配给函数的栈空间被收回，在这个函数中被定义的变量也随之被释放和消失。

堆内存：通过new产生的数组和对象分配在堆内存中。堆内存中分配的内存，由JVM提供的GC（垃圾回收机制）来管理。在堆内存中产生了一个数组对象后，我们还可以在栈中定义一个变量，这个栈中变量的取值等于堆中对象的首地址。栈内存中的变量就成了堆内存中数组或者对象的引用变量。我们以后就可以在程序中直接使用栈中的这个变量来访问我们在堆中分配的数组或者对象，引用变量相当于数组或者对象起的一个别名，或者代号。

引用变量是一个普通的变量，定义时在栈中分配；引用变量在被运行到它的作用域之外时就被释放，而我们的数组和对象本身是在堆中分配的，即使程序运行到使用new产生对象的语句所在的函数或者代码之后，我们刚才被产生的数组和对象也不会被释放。数组和对象只是在没有引用变量指向它，也就是没有任何引用变量的值等于它的首地址，它才会变成垃圾不会被使用，但是它任然占据着内存空间不放（这也就是我们Java比较吃内存的一个原因），在随后一个不确定的时间被垃圾回收器收走。



其实我觉得书上就想说：基本数据类型创建的值存在栈内存中，引用数据类型的值存在堆内存中，
配合上图详解：基本数据类型 int i=3;就是在栈内存中开个房子给 i，名字叫 i  , 里面住着  3  。而 引用数据类型 String str="abc" 就是栈内存给它开后院，叫 str 去 堆内存地址为 0x2253的地方去住，所以引用类型的值存在 堆内存中，而栈内存中存的是它住的房号，也就是值所在的堆内存地址。
这样说不知道你能不能理解。但我想说：图自己画的，文字自己敲的，如果有错，请尊重回答者。