Java入门

1.java特性
1.1简单性
没有头文件、指针运算、结构、联合、操作符重载、虚基类等；
1.2面向对象
与C++的主要不同点在于多继承，java中取而代之的是简单的接口概念，及元类模型；
1.3网络技能
有一个扩展例程库，用于处理像HTTP和FTP这类的TCP/IP协议。java应用程序能够通过URL打开和访问网络上的对象，便捷程度就像访问本地文件一样；
1.4健壮性
早期问题检测、后期动态（运行时）检测、消除了有出错倾向的状态…Java和C++最大的不同在于Java采用的指针模型可以消除重写内存和损坏数据的可能性。
1.5安全性
适用于网络、分布式环境。
能够防范各种攻击：
（1）运行时堆栈溢出。如，蠕虫等病毒常用的攻击手段。
（2）在自己的处理空间之外破坏内存。
（3）未经授权读写文件。
Java的安全机制比ActiveX要强得多，因为他是在应用程序运行时加以控制并制止恶意性破坏的。
1.6体系结构中立
Java编译器通过生成与特定计算机体系结构无关的字节码指令实现这一特性。
虚拟机有个选项，可以将使用最频繁的字节码序列翻译成机器码，这一过程被称为即时编译。虚拟机可以检测指令序列行为，以增强其安全性。
1.7可移植性
数据类型有固定大小；二进制数据以固定的格式进行存储和传输，消除字节顺序的困扰；字符串用标准Unicode格式存储。
作为系统集成部分的类库，定义了可移植接口。
1.8解释型
Java解释器可在任何移植了解释器的机器上执行Java字节码。现在使用即时编译器将字节码翻译成机器码。
1.9高性能
字节码可以（在运行时刻）快速的翻译成运行这个应用程序的特定CPU的机器码。
（即时编译器含有较传统编译器更多的可用信息。例如，知道哪些类已经加载）
1.10多线程
只要操作系统支持，Java中的线程就可利用多个处理器。Java把多线程的实现交给了底层的操作系统或线程库来完成。
1.11动态性
2.Java基本程序设计结构
2.1Java运行时环境(JRE)，包含虚拟机但不含编译器。
2.2final关键字声明常量
2.3Java中没有幂运算

  //静态导入  import static java.lang.Math.*;  ...  pow(x,a);//x^a

2.4检测字符串相等

  s.equals(t);//s和t可以是字符串变量也可是常量  //"=="运算符只能确定两个字符串是否放置在同一位置

2.5构建字符串
需要用很多小段字符串构建一个新的字符串：

  //所有字符串都在单线程中编辑  StringBuilder builder = new StringBuilder();  builder.append(ch);  builder.append(str);  String s = builder.toString();

2.6读取输入

  import java.util.*;  ...  Scanner in = new Scanner(System.in);//输入可见，不适用由控制台输入密码  String name = in.nextLine();//输入行中可能包含空格  String firstName = in.next();  int age = in.nextInt();

2.7文件输入与输出

  //读取：用一个File对象构造一个Scanner对象  Scanner in = new Scanner(new File("E:\\data\\myFile.txt"));  //写入：构造一个PrintWriter对象  PrintWriter out = new PrintWriter("E:\\data\\myFile.txt");

2.8Java中不能在嵌套的两个块中声明同名变量
2.9如果希望在for循环体之外使用循环计数器的最终值，就要确保变量在循环语句之前，且在外部声明：

  int i;  for(i=1;i<10;i++){  ...  } 

2.10大数值
BigInteger类：任意精度的整数运算；
BigDecimal类：任意精度的浮点数运算。
静态的valueOf()方法，可将普通数值转换为大数值

 BigInteger a = BigInteger.valueOf(100); //不能使用熟悉的算术运算符，如+、* BigInteger c = a.add(b);//c=a+b; BigInteger d = c.multiply(b.add(BigInteger.valueOf(2)));//d=c*(b+2);

2.11多维数组，不规则数组
3.对象与类
3.1由类构造对象的过程称为创建类的实例。Java使用构造器构造新实例，前面加new操作符。
3.2对象与对象变量
一个对象变量并没有实际包含一个对象，而仅仅引用一个对象。
Java中，任何对象变量的值都是对存储在另外一个地方的一个对象的引用。new操作符的返回值也是一个引用。

 Data deadline = new Data(); //new Data():构造了一个Data类型的对象，且它的值是对新创建对象的引用。这个引用存储在变量deadline中。

3.3不要编写返回引用可变对象的访问器方法。
如果需要返回一个可变对象的引用应该首先对他进行克隆（存放在另一个位置上的对象副本）。

  class Employee{    ...    public Date getHireDay(){       return (Date)hireDay.clone();    }    ...  }

!!如果需要返回一个可变数据域的拷贝，就应使用克隆。
3.4一个方法可以访问所属类的所有对象的私有数据

  class Employee{    ...    boolean equals(Employee other){      return name.equals(other.name);    }  }  典型调用方式：  if(harry.equals(boss))...

3.5静态域与静态方法
属于类，而不属于任何独立的对象。
（1）可以把公有常量（final域）设计为public。

  public class Math{    public static final double PI = 3.14159265358979323846;  }  public class System{    public static final PrintStream out=...;  }

（2）静态方法是一种不能向对象实施操作的方法。例，Math类的pow()方法：Math.pow(x,a);
可认为静态方法是没有this参数的方法（非静态方法中，this参数表示这个方法的隐式参数）。
!!静态方法不能操作对象，所以不能在静态方法中访问实例域。但静态方法可以访问自身类中的静态域。
3.6方法参数
Java程序设计语言总是采用值调用。
（方法得到的是所有参数值的一个拷贝，方法不能修改传递给它的任何参数变量的内容）
方法参数有两种类型：
基本数据类型；
对象引用。
一个方法不能修改一个基本数据类型的参数；但对象引用作为参数就不同了（方法得到的是对象引用的拷贝，对象引用及其他的拷贝同时引用同一个对象）。

   //x,y被初始化为两个对象引用的拷贝；并不是“引用调用”   public static void swap(Employee x,Employee y){      Employee temp = x;      x = y;      y = temp;    }    //swap(a,b):并没有实现交换数据的结果。交换的是两个对象引用的拷贝。

总结方法参数使用情况：
（1）一个方法不能修改一个基本数据类型的参数（数值型和布尔型）；
（2）一个方法可以改变一个对象参数的状态；
（3）一个方法不能实现让对象参数引用一个新的对象。
3.7可调用方法对域初始化

  class Employee{    ...    static int assignId(){      int r = nextId;      nextId++;      return r;    }    private int id = assignId();  }

3.8调用另一个构造器
关键字this引用方法的隐式参数；还有另外一个含义：

  public Employee(double s){     //调用 Employee(String,double)     this("Employee #"+nextId,s);     nextId++;   }

3.9初始化块
类第一次加载时，会进行静态域的初始化。所有静态初始化语句及静态初始化块将按类定义的顺序执行。
3.10在包中定位类是编译器的工作；类文件中的字节码肯定使用完整的包名来引用其他类。
3.11静态导入

//如果在源文件顶部添加指令：  import static java.lang.System.*;//就可以使用System类的静态方法和静态域，而不必加类名前缀：  out.println("Hello,world");//对Math类实用：   import static java.lang.Math.*;    ...   sqrt(pow(x,2)+pow(y,2));//Math.sqrt(Math.pow(x,2)+Math.pow(y,2));

3.12Java的类加载器明确禁止加载用户自定义的、包名以”java.”开始的类。
用户自定义的类可通过“包密封”机制来解决将各种包混杂在一起的问题。