Java程序设计

第一章：从0开始学习java

java是一种可以编写跨平台应用程序的面向对象程序设计语言。
本章我们要学习的内容有：

1.了解java语言的发展和运行机制

在正式学习java并安装配置开发环境之前，有必要了解一些有关Java的专业术语：
JDK（Java Development Kit ）：编写Java程序的程序员使用的软件
JRE（Java Runtime Environment）：运行Java程序的用户使用的软件
Server JRE （Java SE Runtime Environment）：服务端使用的 Java 运行环境
SDK（Software Development Kit）：软件开发工具包，在Java中用于描述1998年~2006年之间的JDK
DAO（Data Access Object）：数据访问接口，数据访问，顾名思义就是与数据库打交道
MVC（Model View Controller）：模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用于组织代码用一种业务逻辑和数据显示分离的方法
JRE 与 Server JRE 区别, 以下是官网中的说明
Software Developers: JDK (Java SE Development Kit). For Java Developers. Includes a complete JRE plus tools for developing, debugging, and monitoring Java applications.
Administrators running applications on a server: Server JRE (Server Java Runtime Environment) For deploying Java applications on servers. Includes tools for JVM monitoring and tools commonly required for server applications, but does not include browser integration (the Java plug-in), auto-update, nor an installer.

首先要明确一下两个概念上的区别：JDK、SDK。
SDK——soft development kit，软件开发工具包。sdk是一个大的概念，比如开发安卓应用，你需要安卓开发工具包，叫 android sdk，比如你开发java程序，需要用到java sdk，所以一般使用sdk这个概念，你需要在前面加上限定词。
JDK——可以理解为 java sdk，它是编写java程序，使用到的工具包，为程序员提供一些已经封装好的 java 类库。

java语言比较特殊，其编写的程序需要经过编译步骤，但这个编译步骤不会产生特定平台的机器码，而是生成一种与平台无关的字节码（.class文件），这种字节码不是可执行的，要在java虚拟机中通过解释。JVM是java程序跨平台的关键，只要为不同的平台实现相应的虚拟机，编译后的java字节码就可以在该平台上运行。

java虚拟机执行字节码的过程由一个循环组成，它不停地加载程序，进行合法性和安全性检测，以及解释执行，直到系统执行完毕。（包括异常退出）。

2.搭建java开发环境
一个电脑上搭建java的环境

先下载JDK

首先我们需要下载java开发工具包JDK,我这里选择8下载.
下载链接：link

这里测试下jde——创建一个helloworld程序
从txt记事本中编写代码——改变后缀名为.java

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

打开cmd ______这里我存放代码的地方是D:\chapter1
依次输入 d: (打开D盘）
cd chapter1 (打开D:\chapter1文件夹）
输入命令 javac HelloWorld.java
如果没有其它信息出现，则代表没有错误
代码存放的地方出现.class文件


2.解释执行程序
在cmd输入
依次输入 d: (打开D盘）
cd chapter1 (打开D:\chapter1文件夹）
java HelloWorld

下载安装Eclipse

安装教程：link

验证下成功没，接下来创建一个hello world程序
1.打开java透视图


新建java项目

创建新的class

接下来
进行调试和运行

·

调试程序
还有断点设置
下面是一段简单的代码：

public class HelloWorld {
    public static void main(String[] args) {
    	int sum=0;
    	for(int i=1;i<=5;i++) {
    		sum=sum+i;
    	}
        System.out.println(sum);
    }
}

设置断点

进行调试，进入调试界面
可以按ctrl+f6进行逐步调试
注意此时
sum值的变化

第二章 java的基本语法详解

本章我们要学习的内容有：
本章将对java语言的标识符、数据类型、变量、常量、运算符、表达式、控制语句和数组等基础知识进行学习。

本章学习目标：

• 理解标识符
• 熟悉java的基本数据结构
• 掌握运算符
• 熟练掌握各种流程控制语句
• 了解注释结构

2.1标识符和关键字

2.1.1标识符

简单理解为名字
JAVA语言规定标识符由任意顺序的字母、下划线_ 、 美元符号 $ 、和数字组成
并且第一个字符不能是数字；

下面这些是非法的标识符
3max(数字首位）
room#（没有#这个）
class （class为关键字）

注意：

1. 标识符不能是关键字
2. java是严格区分大小写的
3. java语言中的字母不仅包通常的拉丁文字a、b、c \ 等还包含中文，日语以及其他国家的语言

2.1.2关键字

关键字是特定的一些单词，其对java编译器有着特殊的含义。JAVA的关键字可以分为5种

1. 类类型（Class Type)

package, class, abstract, interface, implements, native, this, super, extends, new, import, instanceof, public, private, protected

2. 数据类型（Data Type)

char, double, enum, float, int, long, short, boolean, void, byte

3. 控制类型（Control Type）

break, case, continue, default, do, else, for, goto, if, return, switch, while, throw, throws,try, catch, synchronized, final, finally, transient, strictfp

4. 储存类型（Storage Type)

register , static

5. 其他类型（Other Type)

const , volatile

注意：
1. 所有的关键字都是由小写字母组成的
2. java语言中无sizeof关键字，因为java语言的数据类型长度和表示都是固定的
3. goto与const在java语言中没有含义

2.2基本数据类型

2.2.1 整数类型

整数类型用来储存整数数值，即没有小数部分的数值，可以是正数，也可以是负数。可以用十进制，八进制，十六进制表示
根据内存的大小不同，可分为byte，short，int，long共四种类型。

例子：定义int型变量，实例代码如下：

int x；   //定义int型变量x
int x，y=100； //定义int型变量x，y
int x=450，y=-462 //定义int型变量x，y赋给初值

定义上述变量时，要注意变量的取值范围。
对于long型值，若赋给的值大于int的最大值或者小于int的最小值，则需要在数字后加L或l，表示为长整数，
如long num=3117112897L

2.2.2 浮点类型

浮点类型表示有小数部分的数字。分为单精度浮点类型float和双精度浮点类型double，他们具有不同的取值范围。

在默认情况下，小数都被看作double，若使用float型小数，则需要在小数后面添加F或f。
可以使用后缀d或D来明确表示这是一个double类型数据，不加d不会出错，但声明float不加f，系统会认为变量是double类型而出错。

例子：

float x=100.23f；
double y1=32.12f；
double y2=123.45f；

2.2.3 字符类型

字符类型（char）用于储存单个字符，占用16位（二个字节）的内存空间。在定义字符型变量时，要以单引号表示，'s’表示一个字符，如“s"则表示一个字符串。

char c1='a';

同C与C++一样，Java也可以把字符作为整数对待。由于字符a在Unicode表中的排序位置是97，

char c1=97;

有些字符（如回车键）不能通过键盘录入字符串内，针对这种情况，Java提供了转义字符，以反斜杠\开头，将其后的字符转变成另外的含义。
例如：‘\n’（换行）, ‘\b’ （退格） ,’\t’（水平制表符）

注意：用双引号引用的文字，就是我们平时所说的字符串，它不是原始类型，而是一个·类（class）String，它被用来表示字符序列。

2.2.4 布尔类型

又称逻辑类型，通过关键字boolean来定义，只有true和false二个值，分别代表布尔逻辑中的”真“和”假“。布尔类型通常被用于在流程控制中作为判断条件。

例子：
boolean b1; //定义布尔型变量b1
boolean b2=true; //定义布尔型变量b2,并赋给初值true

注意：在java语言中，布尔值不能与整数类型进行转换，而C和C++允许.

2.3常量和变量

在程序运行过程中，其值不能被改变的量称为常量，值能被改变的称为变量。变量和常量的命名都必须使用合法的标识符。

2.3.1 常量

在程序中值一直不会变的量称为常量，常量在一个程序中只能被赋值一次。

在Java中声明一个常量除了要指定数据类型外，还需要通过final关键字进行限定，声明的语法如下：

final datatype CONSTNAME=VALUE

其中final是关键字，表示的定义的为常量，datatype 为数据类型，CONSTNAME为常量的明称，VALUE为常量的值

例子：

final double Pi=3.1415926; //声明double型的常量Pi

final boolean FLAG=true;   //声明boolean型的常量FLAG并赋值 boolean是布尔类型

注意：常量名通常使用大写字母，但并不是必需的，只是很多Java程序员已经习惯使用大写字母来表示常量，通过这种方式区别变量

2.3.2 变量

在Java中，使用变量之前需要先声明变量。变量声明通常包括3部分：变量类型、变量名和初始值，其中变量的初始值是可选的。

语法如下：

type identifier [=value][,identifier[=value] ···];

其中type是Java中的基本数据类型，或者类、接口复杂类型的名称，identifier是变量的名称，=value表示用具体的值对变量进行初始化，即把某个值赋给变量。

例子：

int age;  //声明int型变量
double d1=12.27;   //声明double型变量并赋值

2.3.3 变量作用域

变量的作用域是指程序代码能够访问该变量的区域，若超出该区域则在编译时会出现错误。

根据作用域的不同，可将变量分为以下几种：

1. 类成员变量
类成员变量在类中声明，它不属于任何一个方法，其作用域为整个类。
例子：

class ClasssVar{
int x=45;
int y;
}

在上述代码中，定义的二个变量x,y 均是类成员变量，其中第一个进行了初始化，而第二个没有进行初始化。

2.局部变量

在类的成员方法中定义的变量（在方法内部定义的变量）称为局部变量。局部变量只是在当前代码块中有效。
例子：

class LocalVart{
public static void main (String []args){
int x=45; //局部变量，作用域为整个main（）
if（x>5){
int y=0;    //局部变量，作用域为if语句块
System.out.printin(y);
}
System.out.printin(x);
}
}

在上述代码中，定义的两个变量均是局部变量，其中x的作用域是整个main()，而y的作用域仅仅局限于if语句块。

3.方法参数变量

声明为方法参数的变量的作用域是整个方法。

例子：

class FunctionParaVar{
  public static int getSum(int x){
  x=x+1;
  return x;
  }
  }

在上述代码中，定义了一个成员方法（getsum）（函数），方法中包含一个int类型的参数变量x，其作用域是整个getSum()方法。

4.异常处理参数变量
异常处理参数变量的作用域在异常处理代码块中，该变量是将异常处理参数传递给异常处理代码块，与方法参数变量的用法类似。
例子：

public class ExceptionParVar{
  public static void main(String []args){
  try{
			System.out.printin("exception");
			}
			catch(Exception e){//异常处理参数变量，作用域是异常处理代码块
			e.printStackTrace();
			}
  }}

在上述代码中，定义了一个异常处理代码块catch，其参数为Exception类型的变量e，作用域是整个catch代码块。

2.4 运算符

计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。我们可以把运算符分成以下几组：

• 算术运算符
• 关系运算符
• 位运算符
• 逻辑运算符
• 赋值运算符
• 其他运算符

2.4.1赋值运算符

以“=”表示。它是一个二元运算符（对两个操作数作处理），其功能是将右边的赋给左方的操作数。例如：

int a=100;

2.4.2 算数运算符

算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。

下表列出了所有的算术运算符。表格中的实例假设整数变量A的值为10，变量B的值为20：

下面的简单示例程序演示了算术运算符。复制并粘贴下面的 Java 程序并保存为 Test.java 文件，然后编译并运行这个程序：

public class Test {
 
  public static void main(String[] args) {
     int a = 10;
     int b = 20;
     int c = 25;
     int d = 25;
     System.out.println("a + b = " + (a + b) );
     System.out.println("a - b = " + (a - b) );
     System.out.println("a * b = " + (a * b) );
     System.out.println("b / a = " + (b / a) );
     System.out.println("b % a = " + (b % a) );
     System.out.println("c % a = " + (c % a) );
     System.out.println("a++   = " +  (a++) );
     System.out.println("a--   = " +  (a--) );
     // 查看  d++ 与 ++d 的不同
     System.out.println("d++   = " +  (d++) );
     System.out.println("++d   = " +  (++d) );
  }
}

以上实例编译运行结果如下：
a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
a++ = 10
a-- = 11
d++ = 25
++d = 27

算数运算符优先级：

顺序	运算符	规则
高	（）	如果有多重括号，首先计算最里面的子表达式的值。若同一级有多对括号，则计算时从左至右
	++，- -	变量自增，变量自减
	*,/,%	若同时出现，计算时从左至右
低	+，-	若同时出现，计算时从左至右

关于++和- -运算符
就是自增和自减运算符。这两个运算符分为前缀式和后缀式。放在变量前面的++和- -,会先将变量的加1或者减1，然后再使此变量参与其他运算。放在变量后面的++和- - ，会先进行下面的其他运算，再将该变量加1或减1；

例子：

public class AutoInc {
	public static void main(String[] args) { 
		int i = 1; 
		int j = 1;
		System.out.println("i后缀递增的值= " + (i++)); //后缀递增
		System.out.println("j前缀递增的值= " + (++j)); //前缀递增
		System.out.println("最终i的值 =" + i);  
		System.out.println("最终j的值 =" + j); 
   }
}

i后缀递增的值= 1
j前缀递增的值= 2
最终i的值 =2
最终j的值 =2

2.4.3 关系运算符

关系运算符实际上就是“比较运算”，将二个值进行比较，判断比较的结果是否符合条件，如果符合，则表达式的结果为true，否则为false。

下表为Java支持的关系运算符

表格中的实例整数变量A的值为10，变量B的值为20：

运算符	描述	例子
==	检查如果两个操作数的值是否相等，如果相等则条件为真。	（A == B）为假。
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。	（A> B）为假。
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。	（A
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。	（A> = B）为假。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。	（A <= B）为真。

实例

下面的简单示例程序演示了关系运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序：

Test.java 文件代码：

public class Test {
 
  public static void main(String[] args) {
     int a = 10;
     int b = 20;
     System.out.println("a == b = " + (a == b) );
     System.out.println("a != b = " + (a != b) );
     System.out.println("a > b = " + (a > b) );
     System.out.println("a < b = " + (a < b) );
     System.out.println("b >= a = " + (b >= a) );
     System.out.println("b <= a = " + (b <= a) );
  }
}
以上实例编译运行结果如下：

a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false

2.4.4 逻辑运算符

有三种，分别是&&（逻辑与）、||（逻辑或）、！（逻辑非）、其中前两个是双目运算符，第三个是单目运算符。

下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假

实例

下面的简单示例程序演示了逻辑运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序：

public class Test {
  public static void main(String[] args) {
     boolean a = true;
     boolean b = false;
     System.out.println("a && b = " + (a&&b));
     System.out.println("a || b = " + (a||b) );
     System.out.println("!(a && b) = " + !(a && b));
  }
}
以上实例编译运行结果如下：

a && b = false
a || b = true
!(a && b) = true

2.4.5 位运算符

用来对二进制的位进行操作，其操作数的类型是整数类型以及字符型，运算结果是整数数据。

假设a = 60，b = 13;它们的二进制格式表示将如下：
A = 0011 1100
B = 0000 1101

---

A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011

下表列出了位运算符的基本运算，假设整数变量 A 的值为 60 和变量 B 的值为 13：
A=60=00111100
B=13=00001101

操作符	描述	例子
＆	如果相对应位都是1，则结果为1，否则为0	（A＆B），得到12，即0000 1100
|	如果相对应位都是 0，则结果为 0，否则为 1	（A|B） 得到61，即 0011 1101
^	如果相对应位值相同，则结果为0，否则为1	（A ^ B）得到49，即 0011 0001
〜	按位取反运算符翻转操作数的每一位，即0变成1，1变成0。	（〜A）得到-61，即1100 0011
<<	按位左移运算符。左操作数按位左移右操作数指定的位数。高位移除舍弃，低位的空位补0	A << 2得到240，即 1111 0000
>>	按位右移运算符。左操作数按位右移右操作数指定的位数。低位移除舍弃，高位补符号位（正数补0，负数补1）	A >> 2得到15即 1111
>>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移。低位移除舍弃，高位补0	A>>>2得到15即0000 1111

实例

下面的简单示例程序演示了位运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序：

Test.java 文件代码：

public class Test {
  public static void main(String[] args) {
     int a = 60; /* 60 = 0011 1100 */ 
     int b = 13; /* 13 = 0000 1101 */
     int c = 0;
     c = a & b;       /* 12 = 0000 1100 */
     System.out.println("a & b = " + c );
 
     c = a | b;       /* 61 = 0011 1101 */
     System.out.println("a | b = " + c );
 
     c = a ^ b;       /* 49 = 0011 0001 */
     System.out.println("a ^ b = " + c );
 
     c = ~a;          /*-61 = 1100 0011 */
     System.out.println("~a = " + c );
 
     c = a << 2;     /* 240 = 1111 0000 */
     System.out.println("a << 2 = " + c );
 
     c = a >> 2;     /* 15 = 1111 */
     System.out.println("a >> 2  = " + c );
  
     c = a >>> 2;     /* 15 = 0000 1111 */
     System.out.println("a >>> 2 = " + c );
  }
} 

以上实例编译运行结果如下：
a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2 = 15
a >>> 2 = 15

2.4.6 条件运算符（?:）

条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

<布尔表达式>?value1:value2

如果布尔运算的结果为true，就返回value1的值；如果为false，则返回value2的值。
使用条件运算符的实例如下：

public class Test {
   public static void main(String[] args){
      int a , b;
      a = 10;
      b = (a == 1) ? 20 : 30;// 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
      System.out.println( "Value of b is : " +  b );
 
      
      b = (a == 10) ? 20 : 30;// 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
      System.out.println( "Value of b is : " + b );
   }
}

以上实例编译运行结果如下：
Value of b is : 30
Value of b is : 20

2.4.7 运算符的优先性与结合性

结合性是指对于同优先级的符号，按结合性决定他们是从左到右计算还是从右到左计算。
绝大部分的运算符都是从左向右计算的，只有
赋值运算符（如“=”，“+=”等）、
一元运算符（如“++” ！- -）
和三元运算符（即条件运算符?:）是从右向左的。

如果不清楚时候，加括号来保证计算顺序。

2.5 数据类型转换

两种方式：隐式类型转换（自动转换）和显式类型转换（强制转换）

隐式类型转换（自动转换）—————
从低级类型到高级类型的转换，系统将自动执行。

byte

实例：代码如下：

int a=3;
double b=a;

此时如果输出b的值，结果为3.0

整形、浮点、字符型数据可以混合运算。不同类型的数据先转换为同一类型，在进行计算。

显式类型转换

当把高级的变为低级的，必须使用显式类型转换

语法规则：

(type) variableName;

实例：

int a=3;
double b=5.0;
a=(int)b; 

此时输出a的值，结果就是5.

2.6 流程控制语句

2.6.1 分支语句

分为if和if-else语句

1. if语句

语句格式为：

if(条件表达式){
语句块
}

实例：
通过键盘输入一个整数，判断该整数是否大于18

 import java.until.Scanner.      //导入包 
  public class IFTest{
  public static void main(String[] Argus){
  System.out.printin(“请输入你的年龄：”);
  Scanner sc=new Scanner(System.in);
  int age=sc.nextlnt(); //接受键盘输入的数据
   if(age>=18){
  System.out.println(“你已经是成年人了！”);
  }
  }
  } 

2.if-else语句
语法：

if(条件表达式){
语句块1;
}else {
语句块2;
}

实例：

package ch3;
import java.util.Scanner;  //导入包
public class IfElseTest {
	public static void main(String[] args){
		System.out.println("请输入你的年龄：");
		Scanner sc = new Scanner(System.in); 
		int age = sc.nextInt();  //接收键盘输入的数据
		if (age>=18){
			System.out.println("成年人");
		}else{
			System.out.println("未成年人");
		}
	}
}

3. if-else嵌套语句

语法：

if(条件表达式1){
if(条件表达式2){
语句块1；
}else{
语句块2；
}else{
. If(条件表达式3){
语句块3；
}else{
语句块4；
}
}

实例：

通过键盘输入两个整数，比较他们的大小：

package ch3;
import java.util.Scanner;  //导入包
public class IfElseNestTest {
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入x1:");
		int x1 = sc.nextInt();
		System.out.println("请输入x2:");
		int x2 = sc.nextInt();
		 if(x1>x2){
             System.out.println("结果是:" + "x1 > x2");
         }else{
            if(x1<x2){
               System.out.println("结果是:" + "x1 < x2");
            }else{
               System.out.println("结果是：" + "x1 = x2");
            }
          }
	}
}

4.switch语句
多分支
语法：

switch (表达式){
case 值1:
语句块1；
break；
case 值2：
语句块2；
break；
…
default ：
语句块n+1；
}

使用switch语句时候，注意：

1. switch后面括号中表达式必须为整形（byte short int）或字符型（char）类型的常量表达式，而不能用浮点型或long类型，也不能为一个字符串。
2. default子句是可选的
3. break语句在执行完一个case分支后，使程序跳出switch语句，即终止switch语句的执行。但在特殊情况下，多个不同的case值要执行一组相同的操作，此时同一组中前面的case分支可以去掉break语句。
4. 一个switch语句可以代替多个if—else语句组成的分支语句，且switch语句从思路上显得更清晰。

例子：

package ch3;

public class SwitchTest {
	public static void main(String[] args){
		   int x=6;
	       int y=9;
		   char op='+'; //运算符
	       switch(op){
	        //根据运算符，执行相应的运算
			case '+':    //输出x+y
				System.out.println("x+y="+ (x+y));
				break;
			case '-':    //输出x-y
				System.out.println("x-y="+ (x-y));
				break;
			case '*':    //输出x*y
				System.out.println("x*y="+ (x*y));
				break;
			case '/':    //输出x /y
				System.out.println("x/y="+ (x/y));
				break;
			default:
				System.out.println("输入的运算符不合适！");				
			}
		}
}

2.6.2 循环语句

Java 循环结构 - for, while 及 do…while

1.while 循环

while是最基本的循环，它的结构为：

while( 布尔表达式 )
{
//循环内容
}
只要布尔表达式为 true，循环就会一直执行下去。

例子：利用while计算1-100的整数之和

package ch3;

public class WhileTest {
	public static void main(String[] args){
	    int sum=0;
	    int i=1;
	    //如果 i<=100，则执行循环体，否则结束循环
		while(i<=100){  
			sum = sum + i;
			//改变循环变量的值，防止死循环
			i = i +1;  
		}
		System.out.println("sum = " + sum);
	}
}

2.do while 语句

对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。

do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

do {
//代码语句
}
while(布尔表达式);

注意：布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false。

例子:利用do-while语句计算5的阶乘，并输出计算结果

package ch3;

public class DoWhileTest {
	public static void main(String[] args){
	    int result=1;
	    int i=1;
	    do{  
			result = result * i;
			//改变循环变量的值，防止死循环
			i = i +1;  
		} while(i<=5) ;
		System.out.println("result = " + result);
	}
}

3. for语句

虽然所有循环结构都可以用 while 或者 do…while表示，但 Java 提供了另一种语句 —— for 循环，使一些循环结构变得更加简单。

for循环执行的次数是在执行前就确定的。语法格式如下：

for(初始化; 布尔表达式; 更新) {
//代码语句
}

for 语句的3个表达式之间用；分开，他们的具体含义如下。

1. 表达式1：初始化表达式，通常用于给循环变量赋初值。
2. 表达式2：条件表达式，它是一个布尔表达式，只有值为true时候才会继续执行for语句中的语句块
3. 表达式3：更新表达式，用于改变循环变量的值，避免死循环。

例子：利用for循环计算1-100之间能被3整除的数之和，并输出计算结果

package ch3;

public class ForTest {
	public static void main(String[] args){
	    int sum=0;
	    int i=1;       
	    for(i=1;i<=100;i++)	{
          if (i%3==0){ //判断 i 能否整除3
			  sum = sum + i;  
          }
		}
	    //打印计算结果
		System.out.println("sum = " + sum);  
	}
}

Java 增强 for 循环

Java5 引入了一种主要用于数组的增强型 for 循环。

Java 增强 for 循环语法格式如下:

for(声明语句 : 表达式)
{
//代码句子
}

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

实例

public class Test {
   public static void main(String args[]){
      int [] numbers = {10, 20, 30, 40, 50};
 
      for(int x : numbers ){
         System.out.print( x );
         System.out.print(",");
      }
      System.out.print("\n");
      String [] names ={"James", "Larry", "Tom", "Lacy"};
      for( String name : names ) {
         System.out.print( name );
         System.out.print(",");
      }
   }
}

以上实例编译运行结果如下：

10,20,30,40,50,
James,Larry,Tom,Lacy,

<增强for循环是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

2.6.3 跳转语句—break与continue语句

break 关键字

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。

break 跳出最里层的循环，并且继续执行该循环下面的语句。

语法
break 的用法很简单，就是循环结构中的一条语句：

break;

例子：利用for循环语句计算1-100的整数之和，当和大于500时候，使用break跳出循环。

package ch3;

public class BreakTest {
	public static void main(String[] args){
		int sum=0;
	    for(int i=1;i<=100;i++){
          sum = sum + i;
          if(sum>500)   	  
             break;
		}
	    System.out.println("sum = " + sum);
	}
}

continue 关键字

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

在 for 循环中，continue 语句使程序立即跳转到更新语句。

在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

语法
continue 就是循环体中一条简单的语句：

continue;

实例：输出1-10所有不能被3整除的自然数。

package ch3;

public class ContinueTest {
	public static void main(String[] args){
	    for(int i=1;i<=10;i++)
	    {
          if(i%3==0)
          {
        	  	continue; //结束本轮次循环
          }
          System.out.println("i = " + i);  
		}
	}
}

2.8数组

2.8.1 一维数组

、

例子：在数组中存放4位同学的成绩，计算这四位同学的总成绩和平均成绩。

package ch3;

public class Array1Test {
	public static void main(String[] args){
		double score[]={76.5,88.0,92.5,65};
		double sum =0;
	    for(int i=0;i<score.length;i++){
	    	sum = sum + score[i];  
		}
	    System.out.println("总 成 绩 为：" + sum);
	    System.out.println("平均成绩为：" + sum/score.length);
	}
}

注意：在java中，数组是一种引用类型，它拥有方法和属性，例如，length就是它的一个属性，利用该属性可以获得数组的长度。

2.8.2 多维数组

注意：以二维数组为例子，可用length()方法测定二维数组的长度，即元素的个数。只不过使用’数组名[i].length"得到的是该行的列数。
下面举例说明：

int [][] arr1={{3,-9},{8,0},{11,9}};

则arr1.length的返回值为3，表示数组arr1有三行。而arr[1].length的返回值为2，表示arr1[1]对应的行有2个元素（2列）

举例：声明一个二维数组，输出该数组中的各元素的值

package ch3;

public class Array2Test {
	public static void main(String[] args){
	    int i=0;
	    int j=0;
	    int ss[][] = {{1,2,3},{4,5,6},{7,8,9}};
	    for(i=0;i<ss.length;i++){
	      for (j=0;j<ss[i].length;j++){
	    	     System.out.print("ss["+i+"]["+j+"]="+ss[i][j]+" ");
	      }
	      System.out.println();
		}
	}
}

代码和课后习题代码地址：link

第三章 面向对象程序准备

3.1 面向对象程序设计的概述

面向对象的理解

1、什么是面向对象（ Object Oriented Programming，简称OOP）
面向对象是一种解决问题的思想，是一种看问题的角度。
其实编程就是把现实世界的语言，翻译成计算机能看懂的语言来执行的过程。
无论是面向对象，还面向过程（C语言），其实就是翻译的方式不同而已。

对比一下面向过程与面向对象：

例子：把大象放进冰箱里

面向过程——一步一步来

面向对象——把个体抽象出来——类class

冰箱放东西的操作抽象出来 ——放东西的方法（可以反复地重复地使用这个类）

再在主函数里调用这个类

这样做的好处就是减少了我们的代码量，让代码的复用性更强了！！

3.2 类与对象

类的定义

在实际编程过程中，我们应该把具有一类特征的事物抽象成一个类，每个具体的事物就是一个类的对象。

static修饰的属性可以通过：类名，属性名名称获取到属性的值

举个例子：
demo1:

demo2:

demo3:

因为是public，因此我在demo1中访问demo2和demo3

打印出来了，没报错，所以public时候类之间可以访问
如果修饰符是空白默认呢？

这时候把demo2，demo3的public删除
再运行发现报错

成员变量

类的对象

类和对象的关系
类(class) — 是对某一类事物的描述
对象(object) — 是实际存在的某类事物的个体，也称为实例(instance)
类是创建对象的模板，对象是类的实例。

创建对象的语法格式

例如：

Employee employee = new Employee ("1000001") //创建一个对象employee 他的初始值为1000001；

声明对象的目的就是使用它，对象的使用包括使用其成员变量和成员方法，运算符“.”可以实现对成员变量的访问和成员方法的使用。

成员变量和成员方法的使用

1.使用成员变量
一旦定义了成员变量，就能进行初始化和其他操作
在同一个类中使用成员变量
例：

class Camera{
int numOfPhotos; //照片数目
public void incrementPhotos()
{
numOfPhotos++; // 增加照片数目，调用成员变量numOfPhotos
}
}

从另一个类中使用成员变量。通过创建且类的对象，然后使用.操作符指向该变量
例：

class Robot{
 Cmera camera = new Camera(); //从上一个类camera中创建一个对象
 public void takePhotos()
 {
 camera.numOfPhotos++; //使用camera对象的成员变量numOfPhotos
 }
 }
 

2.调用成员方法
调用成员方法必须在方法名后跟括号和分号，如Camera类的一个对象camera使用自己的方法计算照片的数目。

camera. incrementPhotos();//调用camera对象的成员函数

调用同类的成员函数
例：

class Camera
{
int numOfPhotos; //照片数目
public void incrementPhotos()
{
numOfPhotos++; // 增加照片数目，调用成员变量numOfPhotos
}
public void clickButton(){
incrementPhotos(); //调用同类的成员函数incrementPhotos()
}
}

调用不同类的成员函数。通过创建类的对象，然后用.操作符指向该函数，例：

class Robot{
 Cmera camera = new Camera(); //从上一个类camera中创建一个对象
 public void takePhotos()
 {
 camera.clickButton();//使用camera对象的成员函数clickButton()
 }
 }

方法中的参数传递

1.传值调用
java中所有原始数据类型的参数是传值的，这意味着参数的原始值不能被调用的方法改变。
例：

class SimpleValue{
		    public static void main(String [] args)	{
			    int x = 5;
		        System.out.println("方法调用前 x = "   +  x);
            change(x);
		        System.out.println("change方法调用后 x = "   +  x);		
}
		    public static void change(int x){
			    x = 4;
		    }
	    }

运行的结果

程序分析：
调用change方法后不会改变main()方法中传递过来的变量x的值，因此最后的输出结果仍然为5。
由此可见，在传值调用里，参数值的一份副本传给了被调用方法，把它放在一个独立的内存单元。
因此，当被调用的方法改变参数的值时，不会反映到调用方法

2.引用调用
对象的引用变量并不是对象本身，它们只是对象的句柄。就好像一个人可以有多个名称，一个对象可以有多个句柄
例：

package text;

class ReferenceValue{
    int x ;
    public static void main(String [] args)	{
	    ReferenceValue obj = new ReferenceValue();
	    obj.x = 5;
    System.out.println("chang方法调用前的x =  "   + obj.x);
	    change(obj);
	    System.out.println("chang方法调用后的x =  "   + obj.x);
    }
    public static void change(ReferenceValue obj){
	     obj.x=4;
    }
}

运行结果

程序分析：
在main（）方法中首先生成obj对象，并将其成员变量x赋值为5，接下来调用类内定义的方法change。
在调用change方法时把main（）方法的obj的值赋给change中的obj，使其指向同一内容
change方法结束，change中的obj变量被释放，但堆内存的对象仍然被main()方法中的obj引用，所以在main()方法中的obj所引用的对象的内容被改变。

注意: java中基本类型数据传递是传值调用，对象的参数传递是引用调用！！！

下面程序演示了一个类对象的创建及使用方式

import java.io.*;

class Employee { // 定义父类: 职员类
	 String employeeName; // 职员姓名
	int employeeNo; // 职员的编号
	double employeeSalary; // 职员的薪水

	public void setEmployeeName(String name) {// 设置职员的姓名
		employeeName = name;
	}

	public void setEmployeeNo(int no) {// 设置职员的编号
		employeeNo = no;
	}

	public void setEmployeeSalary(double salary) { // 设置职员的薪水
		employeeSalary = salary;
	}

	public String getEmployeeName() { // 获取职员姓名
		return employeeName;
	}

	public int getEmployeeNo() { // 获取职员的编号
		return employeeNo;
	}

	public double getEmployeeSalary() { // 获取职员工资
		return employeeSalary;
	}

	public String toString() { // 输出员工的基本信息
		String s;
		s = "编号: " + employeeNo + "  姓名： " + employeeName + "  工资： " + employeeSalary;
		return s;
	}
}

public class test_employee // 主程序，测试employee对象
{
	public static void main(String args[]) { // Employee的第一个对象employee1
		Employee employee1; // 声明Employee的对象employee，也称employee为引用变量
		employee1 = new Employee(); // 为对象employee分配内存
		// 调用类的成员函数为该对象赋值
		employee1.setEmployeeName("王一");
		employee1.setEmployeeNo(100001);
		employee1.setEmployeeSalary(2100);
		System.out.println(employee1.toString()); // 输出该对象的数值

		// Employee的第二个对象employee2，并为对象employee分配内存
		Employee employee2 = new Employee(); // 构建Employee类的第二个对象
		System.out.println(employee2.toString()); // 输出系统默认的成员变量初始值

		 // Employee的第三个对象employee3，并为对象employee分配内存
	    Employee employee3 = new Employee(); //构建Employee类的第二个对象
	    employee3.employeeName = "王华" + ""; // 直接给类的成员变量赋值
	    System.out.println(employee3.toString()); // 输出成员变量初始值

	}
}

运行结果

如果用私有的private
例如：
private string employeeName;
这样的话上面在test_employee类中就不能直接调用employeeName
可以用set和get得到 即obj.setEmployeeName…

public void setEmployeeName(String name) {// 设置职员的姓名
		employeeName = name;
	}

public String getEmployeeName() { // 获取职员姓名
		return employeeName;
	}

3.3 类的构造方法

当创建一个对象时，需要初始化类成员变量的数值。如何确保类的每一个对象都能获取类成员变量的初值？——

构造方法来实现。构造方法包括初始化类的成员变量的代码，当创建类的对象时，它自动执行。

构造方法的定义：
格式如下：

[访问说明符] 类名 [参数列表]
{
}

例如：

public Employee(String name){//带参数的构造方法
employeeName=name;
System.out.println("带有姓名参数的构造方法被调用！");
}

构造方法的规则如下：

• 具有与类相同的名称
• 不含返回值类型,不能定义为void，在方法名前面不声明方法类型
• 不能在方法中用return语句返回一个值
• 一般访问权限为public

java默认构造函数
如果没定义，系统会为这个类产生一个默认的构造函数，这个构造函数是空的

class Customer()
{}
class Customer{
public Customer(){}
}

第三个不可以,void不能在参数里，第四个不行，这样写不能够调用无参的构造函数，第五个如果要无参构造，不能有返回值。

对象数组（类似学生类）

如下，我们以学生类来进行举例学习一下

我先把类Student定义好

package text;

public class Student {
	//定义成员变量
	private int sNO; //表示学号
	private String sName; //表示姓名
	private String sSex; //性别
	private  int sAge; //年龄
	private int sJava; //表示java课程成绩
	
	
	//创建带参数的构造函数
	public Student(int sNO,String sName,String sSex,int sAge,int sJava)
	{
		this.sNO= sNO;
		this.sName=sName;
		this.sSex=sSex;
		this.sAge=sAge;
		this.sJava=sJava;
		
	}

//get函数
	public int getsNO() {
		return sNO;
	}


	public String getsName() {
		return sName;
	}


	public String getsSex() {
		return sSex;
	}


	public int getsAge() {
		return sAge;
	}


	public int getsJava() {
		return sJava;
	}
	
	//主函数
	

}

下面才是重点

package text;

public class Testmain {

	public static void main(String[] args) {
		int  arr[]= {1,2,3,4,56}; //基本数据类型组成的数组
		//还可以用对象来构造数组
		Student[] stuarr = new Student[5]; //定义了一个学生类型的数组
		//也就是说这个数组里面的每一个元素都是Student类的对象
		

	}

}

下面举个课本上的题目：
定义一个表示学生信息的类Student，要求如下：

（1）类Student的成员变量：

nO 表示学号；name表示姓名；sex表示性别；age表示年龄；java：表示Java课程成绩。

（2）类Student带参数的构造方法：

在构造方法中通过参数完成对成员变量的赋值操作。

（3）类Student的方法成员：

getNo（）： 获得学号； getName（）：获得姓名； getSex（）：获得性别； getAge（）获得年龄； getJava（）：获得Java 课程成绩

（4）根据类Student的定义，创建五个该类的对象，输出每个学生的信息，计算并输出这五个学生Java语言成绩的平均值，以及计算并输出他们Java语言成绩的最大值和最小值。

package text;

public class Student {
	//定义成员变量
	private int sNO; //表示学号
	private String sName; //表示姓名
	private String sSex; //性别
	private  int sAge; //年龄
	private int sJava; //表示java课程成绩
	
	
	//创建带参数的构造函数
	public Student(int sNO,String sName,String sSex,int sAge,int sJava)
	{
		this.sNO= sNO;
		this.sName=sName;
		this.sSex=sSex;
		this.sAge=sAge;
		this.sJava=sJava;
		
	}

//get函数
	public int getsNO() {
		return sNO;
	}


	public String getsName() {
		return sName;
	}


	public String getsSex() {
		return sSex;
	}


	public int getsAge() {
		return sAge;
	}


	public int getsJava() {
		return sJava;
	}
	
	




//计算成绩平均数
public  static double Javascoreaverage(Student stu[])
{
	int sum;
	sum=0;
	double average;
	int i;
	for(i=0;i<stu.length;i++)
	{
		sum=sum+stu[i].getsJava();
	}
	average=sum/stu.length;
	return average;
}

//求成绩最大值和最小值
public static void GetMaxMin(Student stu[])
{
	int i;
	int max,min;
	max=0;
	min=stu[0].getsJava();
	for(i=0;i<stu.length;i++)
	{
		if(stu[i].getsJava()>max)
		{
			max=stu[i].getsJava();
		}
		if(stu[i].getsJava()<min)
		{
			min=stu[i].getsJava();
		}
	}
	System.out.println("Java最大值为："+max);
	System.out.println("Java最小值为："+min);
}

//输出信息
public static void display(Student stu[])
{
	int i;
	for(i=0;i<stu.length;i++)
	{
		System.out.println("第"+(i+1)+"个：");
		System.out.println("学号:"+stu[i].getsNO()+" "+"姓名："+stu[i].getsName()+" "+"性别："+stu[i].getsSex()+" "+"年龄："+stu[i].getsAge()+" "+"Java成绩："+stu[i].getsJava());
	}
}

//主函数
public static void main(String [] args)
{
	Student stu[] = new Student[5]; //建立对象数组
	
	Student s1 = new Student(1,"chen","nan",20,90);
	Student s2 = new Student(2,"ren","nan",21,89);
	Student s3 = new Student(3,"xie","nan",22,82);
	Student s4 = new Student(4,"liu","nan",23,89);
	Student s5 = new Student(5,"zen","nv",20,98);
	
	stu[0]=s1;
	stu[1]=s2;
	stu[2]=s3;
	stu[3]=s4;
	stu[4]=s5;
	


	Student.display(stu);
	System.out.println("Java值的平均值为:"+Student.Javascoreaverage(stu));
	Student.GetMaxMin(stu);
	
	
}
}

截图：

我这里输出信息比较纯，以后想到更好的办法在改改,这里新建一个函数来做

3.7重载

在java中，允许同一个类中有二个或二个以上相同的名字的方法，只要它们的参数声明不同即可。——重载

3.7.1 方法重载

对方法重载——二个同名方法
如输出方法：

3.7.2 构造方法的重载

先看下面的例子：

3.8 static、final修饰符详解

static

static是静态修饰符，可以修饰类的属性，也可以修饰类的方法。被static修饰的属性不属于任何一个类的具体对象，是公共的储存单元。任何对象访问它时候，取得的都是相同的数值。

1.静态属性

class StaticTest{
static int i =47;
}

接下声明两个StaticTest对象，但他们同样拥有static.i的一个储存空间，既这两个对象共享同样的i；

StatocTest st1 =new StaticTest();
StatocTest st2 =new StaticTest();

此时st1.i 和st2.i所拥有相同的数值47，因为它们引用的是同样的内存区域。

静态成员变量static可以直接对象引用 st1.i ，也可以使用类引用，如·staticTest.i。而这在非静态成员变量是不行的；

2. 静态代码块