疯狂java的基本总结

jdk下的路径：

bin: 该路径存放了jdk的各种工具命令，常用的java javac命令就在这里面
bin目录绝大部分是包装了lib路径下的tools.jar文件里的工具类

db: 该路径是Java DB的安装路径   database


include：该路径是一些平台特定的头文件


jre： Java程序运行所需的jre环境


lib： 存放jdk工具命令实际执行程序LIB（label Information Base) ，标签信息库


javafx-src.zip： 这个压缩文件存放的就是Java FX核心类库的源代码


src.zip: 存放的是Java所有核心类库的源代码


README和LICENSE等说明文档

jre 与jdk

如果需要开发Java程序  则需要安装jdk   安装了jdk之后 就包含了jre 也可以运行Java程序的
反之，只安装了jre，只是运行环境  市场上不单独提供jvm，jre除了包含jvm之外  还有一些Java程序运行需要的环境


另外  公共jre一般不装的原因是没必要   公共jre是一个独立的jre系统 会单独装在系统的其他路径下
公共jre会向浏览器和系统注册Java运行环境 以此 系统中任何应用程序都可以使用公共jre
只是这个用的少而且我们安装的jre已经足够了  所以没有必要安装公共jre


jvm:
JVM是Java Virtual Machine（Java虚拟机）的缩写，
JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。

Java语言的一个非常重要的特点就是与平台的无关性。而使用Java虚拟机是实现这一特点的关键。
一般的高级语言如果要在不同的平台上运行，至少需要编译成不同的目标代码。而引入Java语言虚拟机后
，Java语言在不同平台上运行时不需要重新编译。Java语言使用Java虚拟机屏蔽了与具体平台相关的信息
，使得Java语言编译程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。
Java虚拟机在执行字节码时，把字节码解释成具体平台上的机器指令执行。这就是Java的能够“一次编译，到处运行”的原因。

一些转义字符：

public class ZhuanYiTest{
public static void main(String[] args){
System.out.print("test111");
System.out.println("\r");
System.out.print("test222\b");
System.out.print("\'\"\\");
}
}

\b 退格符 退一格打印
\r 回车符 退回到最前端
\\      \"     \' 单双引号 反斜杠  

//test22'"\

变量的作用：

编程的本质 就是对内存中的数据的访问和修改
程序所用的数据都保存在内存中 程序员需要一种机制来访问或者修改内存中的数据
这种机制就是变量
每个变量都代表了一块内存，而且变量是有名字的
程序对变量赋值实际上就是把数据装入该变量所代表的内存中

自动转型;

/*
目的：本次实验测试基本类型自动向上转型的现象
解释：自动转型
子类上升到父类
byte--short--int--float--double
多态

程序如下：
class Shape {
　　 static void draw(Shape s) {
System.out.println("Shape draw.");
}
}
class Circle extends Shape {
　　 static void draw(Circle c) {
System.out.println("Circle draw.");
}
}
public class CastTest {
public static void main(String args[]) {
Circle c = new Circle();
Shape.draw(c);
}
}
*/


public class ZiDongZhuanXing{
public static void main(String[] args){
byte a = 1;
short b = 1;
int c = 1;
float d = 1.0f;
//左边的类型比右边的大
b = a;
c = b;
d = c;
System.out.println((double)(a+b+c+d));
}
}

编译型语言和解释型语言
1、编译型语言
需通过编译器（compiler）将源代码编译成机器码，之后才能执行的语言。
一般需经过编译（compile）、链接（linker）这两个步骤。编译是把源代码编译成机器码
链接是把各个模块的机器码和依赖库串连起来生成可执行文件。

优点：
编译器一般会有预编译的过程对代码进行优化。
因为编译只做一次，运行时不需要编译，所以编译型语言的程序执行效率高 
可以脱离语言环境独立运行。


缺点：
编译之后如果需要修改就需要整个模块重新编译
编译的时候根据对应的运行环境生成机器码，
不同的操作系统之间移植就会有问题
需要根据运行的操作系统环境编译不同的可执行文件


代表语言：C、C++、 Pascal、Object-C以及最近很火的苹果新语言swift


2、解释型语言


解释性语言的程序不需要编译，相比编译型语言省了道工序，解释性语言在运行程序的时候才逐行翻译。


优点：
有良好的平台兼容性，在任何环境中都可以运行，
前提是安装了解释器（虚拟机）。
灵活，修改代码的时候直接修改就可以，可以快速部署，不用停机维护。


缺点：
每次运行的时候都要解释一遍，性能上不如编译型语言。


代表语言：JavaScript、Python、Erlang、PHP、Perl、Ruby


3、混合型语言


既然编译型和解释型各有缺点就会有人想到把两种类型整合起来，取其精华去其糟粕。
就出现了半编译型语言。比如C#,C#在编译的时候不是直接编译成机器码而是中间码，
.NET平台提供了中间语言运行库运行中间码，中间语言运行库类似于Java虚拟机。


Java先生成字节码再在Java虚拟机中解释执行。
严格来说混合型语言也属于解释型语言。




动态语言和静态语言


1、动态语言
是一类在运行时可以改变其结构的语言：
例如新的函数、对象、甚至代码可以被引进，
已有的函数可以被删除或是其他结构上的变化。
通俗点说就是在运行时代码可以根据某些条件改变自身结构。
主要动态语言：Object-C、C#、JavaScript、PHP、Python、Erlang。
2、静态语言
与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、C++。
3、注意：


很多人认为解释型语言都是动态语言，这个观点是错的！
Java是解释型语言但是不是动态语言，Java不能在运行的时候改变自己结构。
反之成立吗？动态语言都是解释型语言。也是错的！Object-C是编译型语言，
但是他是动态语言。得益于特有的run time机制
（准确说run time不是语法特性是运行时环境，这里不展开）
OC代码是可以在运行的时候插入、替换方法的。
C#也是动态语言，通过C#的反射机制可以动态的插入一段代码执行


动态类型语言和静态类型语言
1、动态类型语言
很多网上资料把动态类型语言和动态语言混为一谈，
简直是误人子弟。动态类型语言和动态语言是完全不同的两个概念。
动态类型语言是指在运行期间才去做数据类型检查的语言，
说的是数据类型，动态语言说的是运行是改变结构，说的是代码结构。
动态类型语言的数据类型不是在编译阶段决定的，而是把类型绑定延后到了运行阶段。
主要语言：Python、Ruby、Erlang、JavaScript、swift、PHP、Perl。


2、静态类型语言
静态语言的数据类型是在编译其间确定的，写编写代码的时候要明确确定变量的数据类型。
主要语言：C、C++、C#、Java、Object-C。

3、注意：
认为解释型语言都是动态类型语言这个是错的
编译型语言都是静态类型语言。这个也是错的。
swift是编译型语言但是它也是动态类型语言。C#和Java是解释型语言也是静态类型语言。
强类型语言和弱类型语言


1、强类型语言：
强类型语言，一旦一个变量被指定了某个数据类型
，如果不经过强制类型转换，那么它就永远是这个数据类型。
你不能把一个整形变量当成一个字符串来处理。
主要语言：Java、C#、Python、Object-C、Ruby


2、弱类型语言：
数据类型可以被忽略，一个变量可以赋不同数据类型的值。
一旦给一个整型变量a赋一个字符串值，那么a就变成字符类型。
主要语言：JavaScript、PHP、C、C++（C和C++有争议，
但是确实可以给一个字符变量赋整形值，可能初衷是强类型，形态上接近弱类型）这里是因为ascii码的问题


3、注意：


一个语言是不是强类型语言和是不是动态类型语言也没有必然联系。
Python是动态类型语言，是强类型语言。
JavaScript是动态类型语言，是弱类型语言。
Java是静态类型语言，是强类型语言。解释型 强类型语言，静态语言

垃圾回收机制是Java虚拟机提供和的能力
用于空闲时间以不定时的方式动态回收无任何引用
的对象所占用的内存空间
值得注意的是
这个回收的不是对象本身 而是对象所占得内存空间
可以用System.gc()和Runtime.getRuntime().gc()显式通知
但是真的垃圾回收什么时候开始是不可预料的
引用计数法 tracing     compacting     copying     genereation     adative


垃圾收集算法：


引用计数法     顾名思义
使用引用计数器来区分存活对象和不再使用的对象。


tracing算法    追踪
使用根集的概念，基于此算法的垃圾收集器
从根集开始扫描，识别那些可达，那些对象不可达
并用某种方式标记可达对象
基于此算法的垃圾收集器也叫作标记和清除垃圾收集器


compacting算法   压缩致密化
解决堆的问题，将对象移到对中的一端，这样的话
堆就分成了多个空闲区和对象区
收集器会对原来的对象的引用进行更新
这样就可以继续让这些引用在新的位置识别原来的对象


copying算法：
客服句柄的开销和解决碎片的垃圾回收。把堆分成一个对象
区和多个空闲区，程序为在对象区给对象分配空间
当对象区满了后就copy到空闲区 这样就可以在新的对象区
为对象分配内存


generation算法
将堆分成两个或者多个，每个子堆作为对象的一代
节省程序在对象区与空闲区交换的时间


adaptive算法
监控当前堆的使用情况 并且选择适当的算法进行垃圾回收





System.ge()方法：
仅仅是一个请求  但是回收可能不会立即执行
可能只是是垃圾回收容易发生 或者提早发生 
或者是回收的垃圾多一点


finalize（）方法：
有些垃圾因为垃圾回收机制无法进行回收完全
所以会存在内存碎片  此方法是为了解决这个问题的
总之 当垃圾回收器准备释放对象占用的内存之后，首先会
调用这个方法进行一些必要的清理工作 
只有到下一次再次进行 垃圾回收动作的时候
才会真正释放这个对象的内存空间

回收
软引用可能 弱引用会 虚引用会 强引用  顾名思义    就是虚引用相当于没有引用 
必须结合队列来使用  用于跟踪对象被垃圾回收的状态 如果这个队列里面有这个虚引用说明这个对象即将被回收
通过虚引用对应的引用队列来了解对象的状态  从而判断对象是否可以被回收

运算符顺序：

运算符优先级：
分隔符：. [] () {} , ;
单目运算符： ++ -- ~ ！
强制类型转换运算符： （type）
乘除取余： % * /
加减：+ -
移位运算符：>> << >>>
关系运算符：> < >= <= instanceof
等价运算符：== !=
按位与：&
按位异或：^
按位或：|
条件与：&&
条件或：||
三目运算符：？：
赋值：= += -= *= /= ...

c语言与运算符的区别详解：

定义：
C语言数组定义 type arrayName[length];
同时也是可以初始化的，C语言中不允许数组大小做动态的定义
C语言中的数组名不占空间，C语言会为数组分配一块连续的空间


Java格式type arrayName[];或者type[] arrayName;
其中type可以为java中任意的数据类，数组名为合法的标识符 
java不会为数组分配空间，需要用new关键字来实现
java会给数组名提供内存空间

初始化：
在编译阶段，C语言不会检查数组越界的情况，java会检查数组越界
同时java数组可以是引用类型
数组的操作：
java中可以直接进行数组的赋值操作，比如a,b两个都是数组，
我可以复制a数组，a=b;
数组做参数不同：
C语言可以值传递和地址传递 

Java里面是看作为一个对象  只有引用传递  地址传递 不是拷贝  形参和实参指向的是 同一个地址

具体可以参照如下网址http://www.docin.com/p-765505964.html

/*
步骤
1：缓存不可变类，首先创建不可变类
2：缓存用数组实现 加上一个索引也就是位置
3：需要遍历已经缓存的对象，for循环
相等函数自己可以重写，equals与hashCode()
4: 判满.满了就覆盖最后一次缓存的对象
*/
//以下代码没有重写equals方法以及hashCode方法所以返回的是false


class ForeverCache{
private final int age;//成员变量
private static ForeverCache[] cache = new ForeverCache[10];//缓存数组
//索引
private static int pos = 0;
private ForeverCache(int age){
this.age = age;
}
public int getAge(){
return age;
}
public static ForeverCache bianLi(int age){
for(int i = 0;i < 10;i++){
//如果实例已经存在，直接返回实例
if(cache[i] != null && cache[i].equals(age)) {
return cache[i];
}
}
//如果缓存已经满了
if(pos == 10){
cache[0] = new ForeverCache(age);//覆盖掉第一个
pos = 1;
}
else{
cache[pos++] = new ForeverCache(age);
}
return cache[pos-1];
}
}
public class ForeverCacheDemo{
public static void main(String[] args){
ForeverCache c1 = ForeverCache.bianLi(18);
ForeverCache c2 = ForeverCache.bianLi(18);
System.out.println(c1 == c2);
}
}

*
这次要写的是一个不可变类。
不可变类中如果含有引用类作为他的成员，并且这个引用类是可变类，这个类就成为了可变的类
就是这个类不会改变的，包括其类的属性以及行为。
要求就是：  
1：使用private final修饰该类的成员变量
2：提供带参数的构造器，用来根据传入的参数来初始化类的成员变量
3：如果有必要，重写hashCode()方法和equals()方法，保证当判断两个对象相等时
  当hashCode()方法相等时，两个对象用equals()方法也必须相等
4：只位该类的成员变量提供该类的get()方法，不提供set()方法
一下就是代码：
*/


class Forever{
private final int age;
private final String sex;
public Forever(int age,String sex){
this.age = age;
this.sex = sex;
}
public void get(){
System.out.println("age: "+age+"-----sex: "+sex);
}
}
public class ForeverDemo{
public static void main(String[] args){
Forever student = new Forever(18,"man");
Forever stu = new Forever(19,"woman");
stu.get();
student.get();
}
}

java运行机制：

详情参考以下网址：
http://www.cnblogs.com/nktblog/articles/2520994.html
http://blog.csdn.net/eagullx/article/details/6066902

Java虚拟机包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收堆和一个存储方法域。

一个类的初始化过程：
        成员变量初始化
        默认初始化
        显示初始化
        构造方法初始化

下篇继续未完。。。。。。。。。。