第二章 简单的Java程序

一个简单的Java范例

定义一个简单类：

public class TestJava {//（有没有发现着两行还是一样的？）

public static void main(String args[]){//Java的一个简单范例，输出和//乘方

int num = 10;//定义整形变量

num = 30;//修改变量内容

System.out.println(“num的内容是：”+num);//输出内容(这都是什么啊)

System.out.println(“num * num = ”+num*num); //输出乘方

程序运行结果：

num的内容是：30

num*num=900

“//”后面的内容没有输出？（原来这个叫注释，不会被编译）

public class 是Java中的关键字，表示的是定义一个类，在Java中所有操作都是由类组成的。TestJava是程序中类的名称。（原来如此）因为主方法（是什么？）写在此类之中，所以称主类。

Java的基本组成是类，使用public class 和 class 都可以声明一个类，但是前者类名称必须与文件名一致，后者文件名称可以与类名称不一致，但是执行时必须执行生成后的*.class文件。

总结：

定义一个类:

public class 是关键字、名称是 TestJava、下面是主方法还要有大括号、“//”是注释

public class aa{//发现生成的是aa.java了

public static void main(String[] args){

int num = 10;//定义一个整型变量 int表示变量类型为//整型（是什么？）

num = 30;//变量的可以改变，它又等于30了？

System.out.println();//输出 有换行

System.out.print();//输出 没有换行

整数类型

在Java中，整数数据类型可以分为long、int、short、byte、四种，long为64位，也就是8个字节（bytes），可表示范围为-9223372036854775808~9223372036854775807；int为32位，也就是4个字节，表示范围为-2147483648~2147483647；若数据值的范围为-32768~32767时，可以声明为short（短整数）类型；若数据值更小，在-128~127之间时，可以使用byte类型，以节省内存空间。例如，声明一个短整型变量sum时：

short sum;

/*

int sum;整型？

long sum; 长整型？貌似是

*/

经过声明后，Java即会在可使用的内存空间中寻找一个占有两个字节的块供sum变量使用，同时，这个变量的范围只能在-32768~32767之间。

在Java中对于一个整型常量，其默认的是int类型，所以在声明时不要超过int数据类型的范围。代码验证：

public class DataDemo1{

public void main(String[] args){

int num = 9999999999;//错误的

错误提示为：The literal 9999999999 of type int is out of range

我改为long num = 999999999;为什么也不行呢？提示同样的错误。

改为short提示也是同样的错误。（哦，默认的是int类型）

第四天 数据类型转换

1.1 数据类型的转换自动类型转换、强制类型转换1.1.1 数据类型的自动转换自动转换数据类型需注意：（1）转换前的数据类型与转换后的数据类型兼容（2）转换后的数据类型的表示范围比转换前的类型大（3）类型的转换只限该行语句，并不会影响原先定义的变量类型，通过类型的自动转换可以保证数据的精确度。这种转换方式也称为扩大转换。public class DataDemo08{public static void mian(String[] args){int x = 30;float y = 22.19f;System.out.println(“x/y = ”+(x/y));System.out.println(“10/3.5 = ”+(10/3.5));System.out.println(“10/3 = ”+(10/3));}}运行结果：x/y = 1.351960310/3.5 = 2.85714285714285710/3 = 3从结果可以发现，in类型与float类型进行计算之后，输出的结果会变成float类型，一个整型常量和一个浮点型常量进行计算之后，结果也会变为一个浮点数据，而如果是两个int类型的常量进行计算，最终结果还是int类型，而其小数部分将会被忽略。

也就是说，假设有一个整数和双精度浮点数作运算时，Java会把整数转换成双精度浮点数后再作运算，运算结果也会变成双精度浮点数。String可以像普通变量那样直接通过赋值的方式进行声明。字符串是使用“””括起来的。两个字符串之间可以使用“+”进行连接。任何数据类型碰到String类型的变量或常量之后都向String类型转换。（String 是什么）publci class DataDemo09{\public static void main(String[] args){String str = “test”;int x = 30;str = str + x;System.out.println(“str = ” + str);}}程序运行结果：str = test 30public class DataDemo10 {public static void main(){int i = 1;int j = 2;System.out.println(“1+2 = ” + i + j);}}运行结果：1+2=12从以上的输出结果中可以发现，程序的主要目的是要计算i+j的值，但是由于碰到了字符串常量，所以所使用的数据类型都会变为字符串常量，也就是说此时的“+”实际上表示的是字符串连接的含义，对于以上的程序，如果要得到正确的结果，则必须修改为：System.out.println(“1+1 = ” + (i+j));//加上括号之后，就表示输出时先计算两个数字相加的结果。

本章要点

1. Java的数据类型可分为基本数据类型和引用数据类型两种。

2. Unicode为每个字符制定了一个唯一的数值，在任何的语言、平台、程序都可以安心的使用。

3. 布尔（boolean）类型的变量只有true和false两个值。

4. 数据类型的转换可分为“自动类型转换”与“强制类型转换”两种。

5. 算术运算符的成员有加法运算符、减法运算符、乘法运算符、除法运算符和余数运算符。

6. if语句可依据判断的结果来决定程序的流程。

7. 自增与自减运算符有相当大的便利性，利用它们可提高程序的简洁程度。

8. 括号()是用来处理表达式的优先级的，也是Java运算符。

9. 当表达式中的类型不匹配时，有以下处理方法：

a) 占用较少字节deep数据类型会转换成占用较多字节的数据类型。

b) 有short和int类型时，则用int类型。

c) 字符类型会转换成short类型。

d) int类型转换成float类型。

e) 若一个操作数的类型为double，则其他的操作数也会转换成double类型。

f) 布尔类型不能转换至其他的类型。

10. 程序的机构包含顺序结构、选择结构和循环结构。

11. 需要重复执行某项功能时，循环就是最好的选择。可以根据程序的需求与习惯，选择Java所提供的for、while及do…while循环。

12. break语句可以让强制程序脱离循环。当程序运行到break语句时，即会离开循环，继续执行循环外的下一个语句，如果break语句出现在嵌套循环中的内层循环，则break语句只会离开当前循环。

13. continue语句可以强制程序跳到循环的起始处，当程序运行到continue语句时即会停止运行剩余的循环主体，转到循环的开始处继续运行。

14. 选择结构包括if、if…else及switch语句，语句中加上了选择结构后，就像 是“十字路口”，根据不同的选择，程序的运行会有不同的方向与结果。

15. 在循环中也可以声明变量，但所声明的变量只是局部变量，只要跳出循环，这个变量便不能再使用。

数组的静态初始化

数组的内容分为动态初始化和静态初始化两种，之前所用到的都是采用先声明数组之后为数组中的每个内容赋值的方式完成的。也可以通过数组静态初始化，在数组声明时就指定其具体内容。

如果想直接在声明时就给数组赋初值，可以利用大括号完成。只要在数组的声明格式后面再加上初值的赋值即可，格式如下：

数据类型 数组名[] = { 初值0,初值1,.......,初值n};

在大括号内的初值会依序指定给数组的第1、…、n+1个元素。此外，在声明时，并不需要将数组元素的个数列出，编译器根据所给出的初值个数来判断数组的长度。范例：

int score[] = {91,92,93,94,95,96};

在上满的语句中声明了一个整型数组score，虽然没有特别指明数组的长度，但是由于大括号中初值有6个，编译器会分别依序指定给各元素存放，score[0]为91，…，score[5]为96。

数组的静态初始化范例：

class ArrayDemo04{

public static void main(String[] args) {

int score[] = {91,92,93,94,95,96};

for (int i = 0; i < score.length; i++) {

System.out.println(score[i]);

运行结果：

91

92

93

94

95

96

方法的定义

方法就是一段可重复调用代码段，例如，有某段长度约100行的代码，要在多个地方使用此段代码，如果在各个地方都重复编写此部分代码，则肯定会比较麻烦，而且此部分代码如果进行修改，也比较困难，所以此时可以将此部分代码定义成一个方法，以供程序反复调用。

方法的定义在Java中可以使用多种方式，如下面格式中定义的方法可以直接使用主方法main()调用，是因为在方法声明处加上了public

static 关键字（擦，没解释。。。。），方法的定义格式：

public static 返回值类型

方法名称（类型 参数1,类型

参数2）｛

方法的主体

程序语句；

[return 表达式];

｝

注意：如果不需要传递参数到方法中，只要将括号写出，不必填入任何内容。此外，如果方法没有返回值，则在返回值类型处要明确的写出void，此时，在方法中return语句可以省略。方法执行完后无论是否村子返回值都将返回到方法调用处并向下继续执行。

定义一个方法，在主方法中进行调用：

class MethodDemo01{

public static void main(String[] args) {

printInfo();

printInfo();

printInfo();

System.out.println("Hello World");

public static void printInfo(){

char c[] = {'H','e','l','l','o',',','L','X','H'};

for(int i = 0; i < c.length; i++) {

System.out.print(c[i]);

System.out.print("循环打印：");

System.out.print("直接打印：");

System.out.println(c);

程序中可以发现，因为printInfo()方法本身不需要任何的返回值声明，所以使用了void关键字进行声明，表示此方法不需要任何的返回值，所以不需要编写return语句。执行流程图如下：

当调用printInfo()方法时，程序会跳转到printInfo()方法中执行，当printInfo()方法全部执行完之后就会返回调用处向下继续执行。

方法命名规范要求：

在定义类时，全部单词的首字母必须大写，那么在定义方法时也有命名规范要求，即第一个单词的首字母小写，之后每个单词的首字母大写，如printInfo()。

有返回值的方法：

class MethodDemo02{

public static void main(String[] args) {

int one = addOne(10, 20);

float two = addTwo(10.3f, 13.3f);

System.out.println("addOne的结果：" + one);

System.out.println("addTwo的结果：" + two);

public static int addOne(int x, int y){

int temp = 0;

temp = x + y;

return temp;

public static float addTwo(float x, float y){

float temp = 0;

temp = x + y;

return temp;

运行结果：

addOne的结果：30

addTwo的结果：23.6

在方法中可以定义多个变量，这些变量只在方法的内部起作用，所以把这些变量成为局部变量。

本章要点

1、数组是由一组相同的类型的变量所组成的数据类型，他们是以一个共同的名称来表示的。数组按存放元素的复杂程度分为一维、二维及多维数组。

2、使用Java中的数组必须经过声明数组和开辟内存给该数组两个步骤。声明数组时会在栈内存开辟空间，只开辟栈空间的数组是无法使用的，必须有指向的堆内存空间才能够使用，可以使用new关键字开辟堆内存空间，同时指定开辟的空间大小。

3、在Java中要取得数组的长度，可以利用.length来完成。

4、数组访问时要使用下标，如果下标的访问超过了数组的范围，则会出现数组越界异常。

5、Java允许二维数组中每行的元素个数均不相同。

6、方法是一段可重复调用的代码段，在本章中因为方法可以由主方法直接调用，所以要加入public static 关键字修饰。

7、方法的重载为方法名称相同，参数的类型或个数不同。

8、数组的传递属于引用数据类型的传递，传递的是堆内存地址的使用权，一个数组可以有多个名称指向同一个堆内存空间，每一个名称都可以修改堆内存中的内容。

9、Java新特性中提供了可变参数，这样在传递参数时就可以不受参数的个数限制，全部的参数将以数组的形式保存下来。

foreach是Java中的新特性，主要作用是方便的输出数组中的内容。

第五章 面向对象基础篇

面向对象基本概念

早期的程序经历了“面向问题”和“面向过程”的阶段，随着计算机的发展那以及解决问题的复杂性的提高，以往的程序设计方法已经不能够适应相待的软件技术要求，于是，从20世纪70年代开始，相继出现了多种面向对象的程序设计语言，想C++、Smalltalk、Java等都是比较熟知的符合面向对象设计的语言。现在，面向对象的概念和应用已经超越了程序设计和软件开发，扩展到很宽的范围，如苏据库系统、交互式界面。应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。

提示：实例了解“面向过程”和“面向对象”的概念。

例如，现在有两位师傅“面向过程”和“面向对象”要设计一个首饰盒：

（1）“面向过程”：用户提出哪些要求，师傅就针对用户的要求进行制作，直接制作出一个完整的整体，本身也不准备好做首饰盒所需要的工具，而是需要什么再单独拿出来做。

（2）“面向对象”：针对用户提出的要求进行分析，并将分析的结果设计完成一张完整的图纸，与需求的用户确认，然后将一切的准备工作全部处理完之后再分块制作，最后将各个小的部分组装在一起。

对比一下可以发现，“面向对象”师傅要比“面向过程”师傅更能适应用户的变化，而一旦用户有变化之后，“面向过程”师傅基本上要推倒重做，而“面向对象”师傅却可以适应变化。

对于面向对象的程序设计有封装行、继承性、多态性3个主要特性。

String两种实例化方式的区别

String有两种实例化方式，一种是通过直接赋值的方式，另外一种是使用标准的new调用构造方法完成实例化，那么两种方法有什么区别？该使用那种更好呢？

一个字符串就是一个String类的匿名对象，匿名对象就是已经开辟了堆内存空间的并可以直接使用的对象。

验证一个字符串就是String的匿名对象：

class StringDemo06{

public static void main(String[] args) {

System.out.println("\"hello\" equals \"hello\"--" + "hello".equals("hello"));

运行结果：

"hello" equals

"hello"--true

所以String str1 = “hello”;实际上就是把一个在堆中开辟好的堆内存空间的使用权给了str1对象，实际上使用这种方式还有另外一个好处，就是如果一个字符串已经被一个名称所引用，则以后再有相同的字符串声明时，就不会再重新开辟空间。如下代码所示，注意代码的输出结果：

class StringDemo07{

public static void main(String[] args) {

String str1 = "Hello";

String str2 = "Hello";

String str3 = "Hello";

System.out.println("str1 == str2 " + (str1 == str2));

System.out.println("str1 == str3 " + (str1 == str3));

System.out.println("str2 == str3 " + (str2 == str3));

运行结果：

str1 == str2 true

str1 == str3 true

str2 == str3 true

结果都为true，说明3个字符串只限的堆内存地址都是同一个，这也就是说String使用直接赋值的方式之后，只要是以后声明的字符串内容相同，则不会再开辟新的内存空间，如下图：

字符串池：对于String的以上操作，在Java中称为共享设计，这种设计思路是，在Java中形成一个对象池，在这个对象池中保存多个对象，新实例化的对象如果已经在池中定义了，则不再重新定义，而从池中直接取出继续使用。String就是因为采用了这样的设计，所以当内容重复时，会将对象指向已存在的实例空间。

使用new String()的方式实例化String对象：

class StringDemo08{

public static void main(String[] args) {

String str1 = new String("hello");

一个字符串就是一个String类的匿名对象，而如果使用new关键字，不管如何都会再开辟一个心的空间，但是此时，此空间的内容还是hello，所以上面的代码实际上是开辟了两个内存空间，如下图：