（王恩恒）java从入门到精通

Java是一种面向对象的编程语言，由Sun Microsystems（现在为Oracle Corporation）于20世纪90年代初开发，旨在为数字电视行业开发软件应用程序。Java语言以其简单性、可移植性、强大的API支持、可靠性和安全性而闻名。

• 桌面应用系统开发，嵌入式系统开发，电子商务应用，企业级应用开发，交互式系统开发，多媒体系统开发，多布式系统开发，web应用系统开发，移动端应用开发

• Java SE 和Java EE

• 明确目标，多思考·多实践多请教，多查阅资料阅读其他人的源代码

• Java API文档是Java开发人员在开发和编写Java程序时可以使用的在线文档
  

包声明

声明成员变量和局部变量

编写主方法

导入API类库

• byte,short,int,long

• float,double

• char

• boolean

• 标识符可以简单地理解为一个名字，是用来标识类名，变量名，方法名，数组名，文件名的有效字符序列。

• 声明一个整数类型变量和声明一个字符类型变量。对于变量的命名并不是随意的，应该遵守几条规则：1，变量名必须是一个有效的标识符。2，变量名不可以使用java中的关键字。3，变量名不能重复。4，应选择有意义的单词作为变量名。

• 就近原则

• 从右往左处理

• 符号在前：先运算后使用；符号在后：先使用再运算。

• "|"或：只要有一者为1，结果就是1。
• 
  
• "~"取反：0变1，1变0。
• 
  
• "^"异或：两者相同即为0，不同为1。
• 
  
• "<<"左移：空位补0，溢出去掉。
• 
  
• ">>"右移：正数补0，负数补1溢出去掉。
• 
  
• ">>>"无符号右移：整体右移，空位补0，溢出去掉

• java中是表达式就是使用运算符连接起来的符合java规则的式子。运算符的优先级决定了表达式中运算符执行的先后顺序。通常优先级由高到低的顺序依次是：增量和减量运算；算术运算；比较运算；逻辑运算；赋值运算。

• 当把高精度的变量的赋值给低精度的变量时，必须使用显式类型转换运算（又称强制类型转换）占用字节数大的转小的

• if条件语句是一个重要的编程语句，用于告诉程序在某一个条件成立的情况下执行某段语句。而在另一种情况下执行另外的语句。

• 在许多编程语言中，switch语句可以用于根据不同的情况执行不同的代码，switch语句中的expression用于指定要测试的值，每个case语句用于测试一个可能的值。如果expression在任何一个case语句中的值与该case语句匹配，则相应的代码将被执行。如果没有任何一个case语句的值匹配，则执行默认块中的代码。每个case块必须以break语句结束，以避免执行下一个case块。

while循环语句与其他编程语言中的while循环语句非常类似，也是根据条件循环执行一段代码，直到条件不再满足。

以下是while循环语句的结构：

while (condition) {
  // 循环执行的代码，直到condition不再为真
}

• condition是一个布尔表达式，如果该表达式的结果为true，循环内的代码将会执行。每次循环结束后，条件会被重新评估，如果条件仍为true，循环将继续执行。如果条件为false，循环将停止执行并跳转到while循环后面的代码

do while语句与while语句循环语句类似，它们之间的区别是while语句为先判断条件是否成立，再执行循环体。而do while循环语句则先执行一次，循环后再判断条件是否成立,也就是说do while循环语句“{}”中的程序段至少要被执行一次。

语法：do{
        语句序列

}while(条件表达式)；

循环是将我程序设计中最有用的循环语法之一。一个for循环可以来重复执行某条语句。直到某个条件得到满足。for循环由两种语句一举是传统与from语句。一种是foreach语句。

使用break语句可以跳出switch结构。在循环语句结构中，同样也可用break语句跳出当前循环体，从而中断当前循环

是针对break的补充，continue不是立刻跳出循环体，而是跳出本次循环，回到循环的条件测试部分，重新开始循环。在for循环语句中遇到continue后，首先执行循环的增量部分，然后进行条件测试。在while和do while循环中，continue语句使控制直接回到条件测试部分。

声明一个数组变量，指定数组类型和数组名，例如：
int[] myArray;
创建一个数组，分配一段代表该数组的连续内存空间，例如：
myArray = new int[10];
这将创建一个10个整数的数组，它的每个元素都会被默认初始化为0。

或者一步完成声明、创建:

int[] myArray = new int[10];
可以通过下标来访问数组元素：
myArray[0] = 1;
myArray[1] = 2;
myArray[2] = 3;
//... 省略后面的元素
可以使用循环来快速地对数组进行初始化或遍历：
for (int i = 0; i < myArray.length; i++) {
    myArray[i] = i * i;
}
可以使用数组实用工具类Arrays进行一些常见操作，例如排序：
Arrays.sort(myArray);
这些是创建一维数组的基本过程，在实际开发中，我们也可以在创建数组时直接给它赋值，例如：

int[] myArray = {1, 2, 3, 4, 5};
这将创建一个包含5个元素的整数数组，其值分别为1、2、3、4和5。

静态初始化（指定元素值）
静态初始化数组时，需要用一组初始值来指定数组的元素值。例如：

int[] myArray = {1, 2, 3, 4, 5};
在这个例子中，我们声明并初始化了一个大小为5的整型数组，并指定了初始元素值。

动态初始化（指定数组长度）
动态初始化数组时，需要指定数组的大小，然后数组元素会被默认初始化为相应类型的默认值（整型为0，布尔型为false，对象类型为null）。例如：

int[] myArray = new int[5];
在这个例子中，我们声明并动态初始化了一个长度为5的整型数组。

通过循环进行初始化
通过循环进行初始化是比较常见的方法。例如：

int length = 5;
int[] myArray = new int[length];
for (int i = 0; i < length; i++) {
    myArray[i] = i + 1;
}
在这个例子中，我们声明并动态初始化了一个长度为5的整型数组，并通过循环初始化了数组元素的值。

二维数组是数组的一种扩展形式，它可以存储表格或矩阵型数据。声明一个二维数组变量，指定数组类型和数组名，例如：
int[][] myArray;
创建一个二维数组，也就是为数组中每一个元素都创建一个一维数组。注意：创建二维数组时需要同时指定行数和列数，例如：
myArray = new int[3][2];
这将创建一个3行2列的二维数组。这样就可以使用两个下标来访问二维数组中的每一个元素。

可以通过两个下标来访问数组元素：
myArray[0][0] = 1;
myArray[0][1] = 2;
myArray[1][0] = 3;
myArray[1][1] = 4;
myArray[2][0] = 5;
myArray[2][1] = 6;
这将分别给二维数组中的每一个元素赋值。

也可以在创建时指定元素值进行初始化：

int[][] myArray = {{1, 2}, {3, 4}, {5, 6}};
这将创建一个3行2列的二维数组，并且每个元素都已经有初始值了。

二维数组的初始化与一维数组初始化类似，同样可以使用大括号完成：type arrayname[][]={value1,value2,...valuen};.type:数组数据类型。arrayname:数组名称，一个合法的标识符。value：二维数组中各元素，都代表一个一维数组。初始化二维数组，代码如下：int myarr[][]={{12,0},{45,10}};

可以使用循环来遍历数组中的元素。在遍历数组时，可以使用for、while等循环语句，也可以使用增强for循环。

以下是一个使用for循环遍历数组元素的示例：

int[] myArray = {1, 2, 3, 4, 5};
for (int i = 0; i < myArray.length; i++) {
    System.out.println(myArray[i]);
}
在这个例子中，我们声明并初始化了一个整型数组，并使用for循环遍历了数组中的所有元素。在循环中，我们通过数组长度属性 length 获取数组的长度，然后使用下标 i 来遍历数组中的每一个元素。

以下是一个使用增强for循环遍历数组元素的示例：

int[] myArray = {1, 2, 3, 4, 5};
for (int value : myArray) {
    System.out.println(value);
}
在这个例子中，我们使用增强for循环遍历了整型数组中的所有元素，并将元素值输出。在循环中，我们使用“类型 变量名 : 数组”这种语法结构，将数组中的元素一个一个赋值给变量，然后使用变量来处理每个元素。

可以使用 Arrays 类提供的方法来对数组的元素进行填充和替换。Arrays 类是 Java 内置的一个工具类，提供了一系列操作数组的工具方法。语法如下：fill(int[]a,intvalue);a:要进行元素替换的数组。value：要储存数组中所有元素的值。

替换数组部分元素：前改后不改

复制数组元素：空位不0，溢出去掉。新数组名=Arrays.copyof（旧数组名，新数组长度）

查询数组元素：先排序再查询，前含后不含。

封装性，继承性，多态性

局部变量

如果在一个成员方法里定义一个变量，那么这个变量就称为局部变量，局部变量是在方法被执行时创建，在方法执行结束时销毁，局部变量在使用时必须进行赋值操作或被初始化，否则出现编译错误。

public class ilti7_3 {
    //成员变量
    String name;
    int age;
    public ilti7_3(String name,int age) {    //构造方法
        this.name = name;
        this.age = age;
    }
    public String toString() {
        return "我叫"+name+"，今年"+age+"岁。";//定义一个方法名为toString
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ilti7_3 s1 = new ilti7_3("张三",16);
        System.out.println(s1);
        ilti7_3 s2 = new ilti7_3("李四",19);
        System.out.println(s2);
    }

}

子类对象赋值给父类引用

Animal a = new Dog();

自动类型转换

子类类型 子类对象 = （子类类型）父类对象;

final：最终的，最后的。它可以用来声明变量，一旦该变量被设定，就不可再改变我们称之为常量

final修饰方法————该方法不可被重写

被final修饰的类不可被继承，不可被更改如果希望一个类不可被任何类继承，或更改，可以使用将这个类设置为final类。

语法如下：

final 类名{}

class Shape{}                                //圆形类
class Square extends Shape{}                    //正方形类继承图形类
class Circular extends Shape{}                 //圆形类继承圆形类
 
public class Demo6{
    public static void draw(Shape s){            //绘制方法
        if(s instanceof Square){                    //如果是正方形
            System.out.println("绘制正方形");
        }else if (s instanceof Circular){            //如果是圆形
            System.out.println("绘制图行");
        }else{                                    //如果是其他类型
             System.out.println("绘制父类图形");
        }
    }
    public static void main(String[] args){
        draw(new Shape());
        draw(new Squsre());
        draw(new Circular());
    }

通常可以说四边形具有4条边，或者更具体一点，平行四边形是具有对边平行且相等特征性的特殊四边形，等腰三角形.



仅用来描述特征且极具抽象性类，在java中被定义为抽象类

抽象类与方法使用abstract关键词定义

抽象方法语法：修饰符 abstract 返回参数 方法名 (传入参数);

与传统方法不同，抽象方法没有方法体，有抽象方法的类一定是抽象类,当父类是抽象类，有抽象方法时，它的子类要么重写父类的抽象方法，要么定义为抽象类（抽象方法重写之后就是普通方法了）

抽象类语法：修饰符 abstract class 类名{}

接口是抽象类的延伸，可以将它看作是纯粹的抽象类，接口中所有的方法都是抽象方法·，由于java语言每个类只能继承一个父类，因此接口的作用就凸显出来，一个类可以实现多个接口，可以看作一个类可以拥有多个父类（便于理解并不是官方意思）

接口使用interface关键词定义

接口语法：修饰符 interface 接口名

实现 implements

java语言每个类可以实现多个接口

实现语法：修饰符 class 类名 implements 接口1，接口2，...{}
————————————————

8.1.1类目冲突
Java中每个接口或类都来自不同的类包，无论是Java API的类与接口还是自定义类与接口，都需要隶属于某一个类名，这个类包含了一些类和接口，如果没有包的存在，管理程序中的类名称是一件非常麻烦的事情，如果程序由一个类组成，自然不会出现类名重叠的问题，但是随着程序的类的数量增多，难免会出现这一问题。

8.1.2创建包
在eclipse中创建包的步骤如下：
（1）在项目的src节点上右击，选择“新建”/“包”的命令

  (2)弹出“新建java包”对话框，在“名称”文本框中输入新建的包名，如com.mr，然后单击“完成”按钮

（3）在eclipse中创建类时，可以在新建立的包上右击，选择“新建”命令，这样子新建的类会默认保存在该包中。另外也可以在new java class对话框中指定指定新建类所在的包。

内部类可以使用外部类的成员

异常是指在程序运行期间出现的错误或异常情况。Java 提供了一套异常处理机制，程序员可以利用这些机制来优雅地处理异常

当程序运行过程中出现异常情况时，会自动抛出异常。如果异常没有被处理，程序会停止执行。Java提供了try/catch和throw关键字来处理异常。

抛出异常
使用throw关键字可以在代码中手动抛出异常。例如：
public void divide(int a, int b) throws ArithmeticException{
    if(b == 0){
        throw new ArithmeticException("除数不能为0");
    }
    System.out.println(a/b);
}
在上述代码中，当除数为0时，手动抛出一个ArithmeticException异常。

捕捉异常
使用try/catch语句块可以捕捉和处理异常。例如：
try {
    // 可能会产生异常的代码
} 
catch (Exception1 e1) {
    // 处理异常1，例如打印日志
} 
catch (Exception2 e2) {
    // 处理异常2，例如发送邮件通知管理员
} 
finally {
    // 无论是否产生异常，都会执行的代码
}
在上述代码中，任何抛出Exception1或Exception2异常的代码块都将会被捕获并且由相应的catch代码块进行处理。finally语句块中的代码必定会执行，并且会在try-catch块结束后执行。

抛出和捕捉自定义异常
在Java中，除了使用系统自带的异常类，我们也可以自定义异常类来更好地处理异常。例如：
public class MyException extends Exception{
    public MyException(String message){
        super(message);
    }
}

public class Demo{
    public static void main(String[] args){
        try{
            throw new MyException("自定义异常");
        }catch(MyException e){
            System.out.println(e.getMessage());
        }
    }
}

使用java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户只需要继承Exception类即可自拟定异常类。在程序中使用自定义异常类，大体可分为以下几个步骤：1.创建自定义异常类。2.在方法中通过throw关键字抛出异常对象。3.如果在当前抛出异常的方法中处理异常，可以使用try-catch语句块捕获并处理，否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。4.在出现异常的方法都调用者中捕获并处理异常。

throws关键字通常被用于声明方法时，用来指定可能抛出的异常，多个异常可使用逗号分隔。throw通常用于方法体中，并且抛出一个异常对象，程序在执行到throw语句立刻中断，它后面的语句不会执行

RuntimeException异常时程序运行中抛出的异常，java类库的每个包中都定义了异常类所有这些类都是Throwable类的子类，Throwable类派生了两个子类，分别是Exception类和Error类，Error类及其子类用来描述java运行系统中的内部错误以及资源耗尽的错误，这类错误比较严重，Exception类称为非致命性类，可以通过捕捉处理来使程序继续执行，Exception类又根据错误发生的原因分为 RuntimeException异常和除 RuntimeException异常之外的异常。

java异常强制用户考虑程序的强健性和安全性，异常处理不应用来控制程序的正常流程，其主要作用是捕获程序在运行时发生的异常并进行相应处理，编写代码处理某个方法可能出现异常时，可遵循以下几条原则：
1.在当前方法声明中使用try-catch语句捕获异常
2.一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或者异常的子类
3.如果父类抛出多个异常，则覆盖方法必须抛出那些异常的一个子集。不能抛出新异常。

Double类和Float 类是对double、float 基本类型的封装,它们都是Number 类的子类,都是对浮点数进行操作，所以常用方法基本相同。
  Double 类在对象中包装一个基本类型为double 的值，每个Double类的对象都包含一个double 类型的字段。此外,该类还提供多个方法,可以将double 类型转换为String 类型,将String 类型转换为double类型，也提供了其他一些处理double类型时有用的常量和方法。

Boolean类将基本类型为boolean的值包装在一个对象中。一个Boolean 类型的对象只包含一个类型为boolean的字段。此外，此类还为boolean类型和String 类型的相互转换提供了许多方法，并提供了处理boolean 类型时非常有用的其他一些常量和方法

Character类在对象中包装一个基本类型为char的值，该类提供了多种方法，以确定字符的类别(小写字母、数字等)，并可以很方便地将字符从大写转换成小写，反之亦然。Character 类提供了很多方法来完成对字符的操作。

在Java中，没有格式化的数据遵循以下原则：

1.如果数据绝对值大于0.001并且小于10000000，使以常规小数形式表示。

2.如果数据绝对值小于0.001或者大于10000000，是用科学计数法表示。

DecimalFormat中的特殊字符及其所代表的含义如下：

Math类提供了众多数学函数方法，这些方法都被定义为static形式

形式调用如下：Math.数学方法

在Math类中，除了函数方法外还存在一些常用数学常量，如PI、E。

形式调用如下：

Math.PI

 Math.E

Random对象创建一个随机数生成器语法如下：
Random r = new Random;

设置随机数生成器的种子 语法如下：

Random r = new Random(seedValue); 

r: Random类对象。
seedValue：随机数生成器的种子。
在Random类中，提供了获取各种数据类型随机数的方法，下国之伙2今孙田计前
public int nextInt):返回一个随机整数。
public int nextInt(int n):返回大于等于0且小于n的随机
public long nextLong()：返回一个随机长整型值。
public boolean nextBoolean):返回一个随机布尔型值。
public float nextFloat()：返回一个随机单精度浮点型值。
public double nextDouble()：返回一个随机双精度浮点型应 
public double nextGaussian):返回一个概率密度为高斯少士8台晰明向叶进研

在Biglnteger类中封装了多种操作，除了基本的加、减、乘、除操作，还提供了绝对值、相反数、最大公约数以及判断是否为质数等操作。
使用BigInteger类，可以实例化一个BigInteger对象，并自动调用相应的构造函数。BigInteger类具有很多构造函数，但最直接的一种方式是参数以字符串形式代表要处理的数字。
例如，将2转换为BigInteger类型，可以使用以下语句进行初始化操作：


Biglnteger twolnstance =new Biglnteger("2");


注意:参数2的双引号不能省略，因为参数是以字符串的形式存在的。

       一旦创建了对象实例，就可以调用Biglnteger 类中的一些方法进行运算操作，包括基本的数学。算和位运算以及一些取相反数、取绝对值等操作。下面列举了Biglnteger类中常用的几种运算方法：public BigInteger add(BigInteger val)：做加法运算。
public BigInteger subtract(BigInteger val)：做减法运算。
public BigInteger multiply(BigInteger val)：做乘法运算。
public BigInteger divide(BigInteger val)：做除法运算。
public BigInteger remainder(BigInteger val)：做取余操作。
public BigIntegerl] divideAndRemainder(BigInteger val):用数组返回余数和商，结果数组中第一个值为商，第二个值为余数。
public BigInteger pow(int exponent):进行取参数的exponent次方操作。
public BigInteger negate()：取相反数。
public Biglnteger shiftLeft(int n)：将数字左移n位，如果n为负数，做右移操作。public BigInteger shiftRight(int n)：将数字右移n位，如果n为负数，做左移操作。public BigInteger and(BigInteger val)：做与操作。
public BigInteger or(BigInteger val)：做或操作。
public int compareTo(BigInteger val):做数字比较操作。
public boolean equals(Object x)：当参数x是BigInteger类型的数字并且数值与对象实例的数值相等时，返回true。
public BigInteger min(BigInteger val)：返回较小的数值。
public BigInteger max(Biglnteger val)：返回较大的数值。

在BigDecimal类，常用的两个构造方法如下：

11.3.1 控制台输出字符
1.不会自动换行的print()方法
printO方法的语法如下：


System.out.print("Hello!");


此方法输出“Hello”文字，输出完毕后，光标会停留在“Hello”文字末尾，不会自动换行。
2. 可以自动换行的 println()方法


printlnO方法在print后面加上了“1n”后缀(就是line的简写)，语法如下：


System.out.println(”书籍是人类进步的阶梯！”)；


此方法输出“书籍是人类进步的阶梯！”后会自动换行。光标停留在下一行的开头。

使用Scanner类扫描控制台的代码如下：

Scanner sc = new Scanner(System.in);

使用Scanner类扫描控制台的代码如下：

Scanner sc = new Scanner(System.in);

DateFormat 类是日期时间格式化子类的抽象类，可以按照指定的格式对日期或时间进行格式化。DateFormat类提供了很多类方法，以获得基于默认或给定语言环境和多种格式化风格的默认日期时间Formatter，格式化风格主要包括SHORT、MEDIUM、LONG和FULL4种：
SHORT：完全为数字，如12.13.52或3：30pm。
MEDIUM：较长，如Jan 12,1952。
LONG:更长，如January 12,1952或3：30：32pm。
FULL：完全指定，如Tuesday、April 12、1952AD或3：30:42pm PST。
  另外，使用DateFormat类还可以自定义日期时间的格式。要格式化一个当前语言环境下的日期，首先需要创建DateFormat类的一个对象，由于它是抽象类，因此可以使用其静态方法 getDateInstance()进行创建，语法如下：


DateFormat df =DateFormat.getDatelnstance();

 DateFormat 类的常用方法及其说明如下：

Calendar 提供了一个类方法 getnstance()，以获得此类型的一个通用的对象。Calendar类的grtnstance()方法返回一个Calendar对象，其日历字段已由当前日期和时间初始化，其使用方法如下：


Calendar rightNow =Calendar.getlnstance();


说明：由于Calendar类是一个抽象类，不能用new创建实例对象，因此除了使用getInstance0方法创建其对象，如果需要创建其对象，必须使用其子类，如GregorianCalendar类。

本地命令指的是操作系统的命令。例如，在Linux系统下就表示shell命令，在Windows系统下就表示cmd命令。
Rutime类提供exec()方法让Java代码可以执行系统的命令，exec)方法有很多重载的形式，例如：


Process exec(String command)
Process exec(String， cmdarray)


command：要执行的系统命令，字符串类型。
cmdarray：要执行的命令和相应的命令参数，字符串数组类型。
其实这两个重载方式很类似，如执行“javac hellojava”这行命令，使用第一种重载方式的代码如下：


Runtime.getRuntime().exec("javac hello.java");


使用第二种重载方式的代码如下：


String command，=("javac","hello.java"];
Runtime.getRuntime().exec(command);


exec)方法会返回一个 Process对象。Process类是Java中进程类，该类是抽象类，不能使用new关键字创建实例。Process类的常用方法如表11.22所示，开发可以使用getlnputStream)方法获取进程返回的信息。

Runtime类可以通过freeMemory（）方法查看当前java虚拟机可用内存的剩余量。如果程序能够实时监控内存剩余量，就可以尽量控制程序对内存的占用，从而避免出现“内存溢出”的情况。同样，也可以用来对测试程序性能，检验程序算法是否导致内存紧张。