java讲稿(2)

Java讲稿

约法三章：第一个月所有人不要带教材，空手来；第一个月不得使用工具，只能用记事本（txt）编写程序；第一排座位空着，所有人手机放在第一排。

1：邂逅java

1.1Ock：

在1991年的时候，sun公司（斯坦福大学校园网（Stanford University Network）的首字母缩写）参与竞标一个green的项目。这个项目类似于今天的嵌入式开发，只是最早打算采用c++来进行开发。C++的开发比较复杂，所以sun公司的工程师在c++的基础上开发了一个新的平台，这个平台就称之为ock。Ock这个词原意指的是橡树。一般程序员在编写程序的时候，会间歇性的犯傻，思考的时候目光呆滞的望到窗外。所以程序员在给这个开发平台命名的时候，窗外的一棵橡树映入眼帘，并成功的影响了某个屌丝的思维，既然没有一个令人满意的名称，那就叫橡树吧——ock。

1.2Java：

在后来的竞标中，那帮屌丝没有成功，当一个项目没有竞标成功的时候，基本就悲催了，一般的下场是无家可归，要么殉葬，要么改嫁。这帮屌丝选择另寻出路，由于当时浏览器技术非常流行，所以他们基于ock又开发了一套浏览器——hotjava。当然，现在hotjava已经淹没在历史的长河中了，只有些许无聊的人还记得她年轻时的容颜，譬如我们。产生的这个新语言（即我们要邂逅的java）突然发现不能被注册，以为已经被注册过了，所以需要马上给他起个新名字。屌丝看到身边的咖啡，是产自爪哇的咖啡，就命名为java。

1.3 Java的三个分支：java se；java ee；java me。

Java SE 是Java平台标准版的简称（Java Platform, Standard Edition） (also known as Java 2 Platform) ，用于开发和部署桌面、服务器以及嵌入设备和实时环境中的Java应用程序。 Java EE（Java Platform，Enterprise Edition）是sun公司推出的企业级应用程序版本。这个版本以前称为 J2EE。能够为我们帮助开发和部署可移植、健壮、可伸缩且安全的服务器端 Java应用程序。Java EE 是在 Java SE 的基础上构建的，它提供Web 服务、组件模型、管理和通信 API，可以用来实现企业级的面向服务体系结构（service-oriented architecture，SOA）和 Web 2.0应用程序。

Java ME(Java Platform,Micro Edition）是一种高度优化的Java运行环境，主要针对消费类电子设备的，例如蜂窝电话和可视电话、数字机顶盒、汽车导航系统等等。JAVA ME技术

在1999年的JavaOne Developer Conference大会上正式推出，它将Java语言的与平台无关的特性移植到小型电子设备上，允许移动无线设备之间共享应用程序。

1.4 java的特点：

1、简洁有效，java相对于其他语言来说是十分简单的。 2、可移植性，java程序可以移植到其他平台运行。 3、面向对象，java就是围绕着对象来编写程序的。 4、解释型，

5、适合分布式计算， 6、健壮性，

7、多线程处理能力， 8、动态语言，

9、安全性，中间生产字节码文件。 。。。

1.5 java应用程序运行机制：

计算机高级编程语言：编译型、解释型。 Hello.java?编译?hello.class?解释?hello

Java在这个过程中执行两种语言：javac.exe（编译语言）java.exe（解释语言） java程序的组成：java源文件、字节码文件、机器码指令。

1.6 java虚拟机（java virtual machine）

在一台计算机上由软件或硬件模拟的计算机，其作用是读取并处理经编译过的与平台无关的字节码文件（class）。

Java编译器针对虚拟机产生字节码文件（class），这个文件与承载的平台没有关系，搁在哪都能用，只要有虚拟机的支持，这就是java独立于平台的原因。 Java解释器负责将java虚拟机的代码在特定的平台上运行。

|? jvm for windows（windows平台） Hello.java?编译?hello.class?|? jvm for dos（dos平台） |? jvm for unix（unix平台） |? …(其他平台)

Java程序中最大的看点就是她的可移植性，一个程序，可以同时在多个平台上执行，而不用改变程序本身，因为执行的class只编译一次就够了，在哪运行就看jvm在哪个平台上就行了。当然了，要改变class文件还得需要改变java文件并重新编译一次。

2 java运行环境的搭建

安装jdk

配置java开发环境

掌握path和classpath的作用 了解java编程经常使用的工具 运行一个简单的程序

2.1 jdk

JDK 是整个Java的核心，包括了Java运行环境、Java工具和Java基础类库。 JDK包含的基本组件包括：

javac – 编译器，将源程序转成字节码

jar – 打包工具，将相关的类文件打包成一个文件 javadoc – 文档生成器，从源码注释中提取文档 jdb – debugger，查错工具

java – 运行编译后的java程序（.class后缀的）

appletviewer：小程序浏览器，一种执行HTML文件上的Java小程序的Java浏览器。 Javah：产生可以调用Java过程的C过程，或建立能被Java程序调用的C过程的头文件。 Javap：Java反汇编器，显示编译类文件中的可访问功能和数据，同时显示字节代码含义。 Jconsole: Java进行系统调试和监控的工具 常用的包：

java.lang： 这个是系统的基础类，比如String等都是这里面的，这个包是唯一一个可以不用引入(import)就可以使用的包

java.io：这里面是所有输入输出有关的类，比如文件操作等

java.nio：为了完善io包中的功能，提高io包中性能而写的一个新包 ，例如NIO非堵塞应用

java.net：这里面是与网络有关的类，比如URL，URLConnection等。 java.util：这个是系统辅助类，特别是集合类Collection，List，Map等。 java.sql：这个是数据库操作的类，Connection， Statement，ResultSet等 javax.servlet：这个是JSP，Servlet等使用到的类 jdk的下载

可以从www.sun.com上去下载jdk的最新版本。如：jre-6u24-windows-i586

安装这个文件，在过程中若修改安装路径时，注意jre的路径也改成相同的路径，保证jdk与jre在同一父目录下。

例如：D:\\Java\\jdk1.6.0_21；D:\\Java\\jre6

在D:\\Java\\jdk1.6.0_21\\bin目录下即可找到javac.exe（编译语言）java.exe（解释语言） JRE（Java Runtime Environment，Java运行环境），运行JAVA程序所必须的环境的集合，包含JVM标准实现及Java核心类库。

2.2 设置环境变量

目前javac.exe（编译语言）java.exe（解释语言）还不能直接运行，这是因为现在并未指定path路径，计算机并不知道这两个语言在哪里。如何告诉计算机要执行的命令存放的位置，更改环境变量来实现。运行cmd，输入javac测试一下。 Path：设置java运行的命令路径

Classpath：设置字节码文件存放路径 设置步骤：右键我的电脑?属性?高级?环境变量。查看是否有path和classpath两个环境变量，修改的方法是将bin路径放在path中，与前面原有路径用英文引号;隔开。例如：D:\\Java\\jdk1.6.0_21\\bin

Classpath放置的是生产的字节码文件，即class文件，值为.; D:\\Java。其中.表示当前路径，后面设置的路径表示class文件存放的路径，可自行设定。这次重新运行cmd，输入javac命令，是不是可以正确执行了。

2.3 第一个java程序

一般我们学习一个程序，第一个遇到的例子，肯定就是helloworld。这次我们也是输出一个字符串，内容为“hello world！！”。为了便于大家预习或复习，所有的实例我会采用以下的方式书写，希望同学们都能动手做一遍。 实例1：helloworld.java

目标：实现后台打印输出字符串“hello world！！” 文件名：helloworld.java 文件路径：E:\\java\\1 学习内容：类 代码内容：

public class Hello{ public static void main(String args[]){ System.out.println(\； } } 代码分析：这是第一次写java代码，所以罗嗦一点，把代码中每个要点都说明一下。 Hello：这是此实例的类名称。类是定义的新的数据类型，是多个对象所共有的属性和方法的集合。类的书写规范就是： [访问符][修饰符]class<类名>{ [属性] [方法] } Public：访问符，说明此类是公共类访问权限。权限共有4种，其他三个为：protected（受保护的）；private（私有的）；缺省（就是什么也不写）。

Static：修饰符，说明此类的特性为静态类。修饰符有三个，其他为：abstract（抽象类）；final（最终类）。

Class：这是定义类的关键字。 Void：表示无返回值类型。

System.out.print()：是输出的方法。加上ln是换行输出，括号内为输出的内容，字符串需要加上双引号。

尝试运行一下，看看是否成功？

结果是提示一个错误：Hello类没有定义。这是刚刚接触java常犯的第一个错误，文件名与主类名不一致。注意一下Java是对大小写敏感的，我们应该把文件名改成HelloWorld.java，并且在程序中将类名一致起来改成HelloWorld.java。改过来之后再试一次，是不是还是失败，在输出语句的后面，是一个中文输入的“；”，这是常犯的第二个错误，中英文混淆。把

它改成英文的“;”，然后再试一次，怎么样，恭喜你成功输出字符串了。

多说两句，java的命名有一些约定俗成的潜规则，例如，类的命名首字母大写，多个字母组成的，每个首字母都大写；常量的命名为大写字母，单词组成的每个字母都大写；变量的命名为小写字母，单词组成的每个字母都小写；方法的命名为首字母小写，多个单词组成的，首字母小写后面每个单词首字母大写；包的命名为公司或单位域名的倒写。

课堂练习：随机一人，自行编写以上代码，输出内容为自己姓名。一次不成功者，男生五个俯卧撑，女生五次抱头下蹲，换一人改错，一次不成功者类推。

3 简单java程序

掌握public class与class声明的区别 掌握java中注释的使用方法 掌握java中标示符的命名规则 了解java中的关键字 掌握变量与常量的声明

3.1 从一个简单的java程序说起

实例2：Square.java

目标：实现一个数字的平方并后台打印输出结果 文件名：Square.java 文件路径：E:\\java\\2

学习内容：类的声明，注释的用法 代码内容： public class Square{ public static void main(String args[]){ } /* int num = 100 ; // 定义一个整型变量 // num = 200 ; // 修改变量的内容 System.out.println(\的内容是：\System.out.println(\System.out.println(1) ; System.out.println(1.1) ; 这是多行注释方法，中间内容不会被执行 你看可以编写多行 没错，确实可以编写多行 */ }; class A //创建一个类A { };

class B //创建一个类B { }; 代码中首先定义主类，类名切记与文件名一致。再确定主方法，静态，无返回值类型。方法体中先定义一个整型变量num，初值赋值为100，再使用输出方法打印输出num*num的值。输出方法内原样输出的用双引号括起来。若是输出的值类型为整型、长整型、单双精度型数据，不用再加双引号。比如输出1或者1.1试一试。

思考一下，程序中输出改成System.out.println(“1”) ; System.out.println(“1.1”) ;行不行，是怎么个情况？

除了定义的主类外，可以添加自定义的类，使用class关键字来修饰。例如添加一个A类，一个B类。

Public class定义的类必须与文件名一致，文件中只允许有一个；class定义的类可以与文件名不一致，文件中可以有多个。

思考一下，主类Square在编译后会生成一个Square.class文件，那么自定义的A和B会不会生成字节码文件呢。试一试。我们了解了java的平台无关性，class生成的类，是否可以直接拿来用，不牵扯文件主类呢？再试一试。

一个正儿八经的程序员，会为代码加注大量的注释，一般一段代码其中有三分之二是注释，加注的方法分单行和多行两种方式，单行为双斜线“//”，多行为“/**/”。在项目中还有文档注释的方式，格式为“/**….*/”。所以注释的方式共计为三种，单行、多行、文档。注释的作用不仅仅是解释代码的含义，还可以在编辑的过程中帮助我们调整检测代码，试一下把num的值改成200，运行一次，再注释掉，然后再运行一次。

3.2 java中标示符的命名规则

Java中书写包、类、方法、参数、变量的名字，要符合java的标示符命名规则。规则是任意顺序的大小写字母、数字、下划线和$来组成。要求是开头不能为数字，也不能为java保留字。其实，老实巴交的用英文单词来命名，不会拼的话就用拼音，又好记又不会出错。 例如：Myname；my_name；myname1；my$name； 这些就是错误的：class；123myname；my name；

Java保留字又称为关键字，不需要刻意去记住他们，在编辑软件中会自动用蓝色标记出来的，用的多了，自然就记住了。需要注意的是有两个关键字并没有启用，一个是goto，一个是const，他们没有任何意义。有三个单词有特殊意义，也不要使用，分别是true、false、null。

3.3 变量和常量

变量：内存中保留下来的一块区域以供程序使用，存储的内容是可变的。 常量：使用final关键字来定义常量，常量被设定之后，不允许修改。 Java中的变量必须先声明再使用。 声明变量时必须使用显式声明的方式。 声明时可以使用“=”对变量进行初始化。

可以同时声明多个同一数据类型的变量，中间使用“，”隔开。

4 Java的数据类型

掌握java数据类型的划分 掌握8种基本数据类型 掌握数据类型的转换

4.2 Java的数据类型

前面实例2中已经用到了一个类型——整型（int）。java中还有很多其他的数据类型，如下表所示： 数值型 基本数据类型 数据类型 引用数据类型 字符型（char） 布尔型（boolean） 类（class） 接口（interface） 数组 数据类型分成两大类——基本数据类型和引用数据类型。 基本数据类型就是具体的值；

引用数据类型传递的事内存的地址，类似c中的指针；

基本数据类型既然是具体的值，自然就有一个取值范围的问题，通过下面这个表来了解。 No 类型 位 范围 1 2 3 4 5 6 7 8 Byte Short Int Long Char Float Double Boolean 8 16 32 64 8 32 64 1 -128~~127 -32768~~32767 -2147483648~~2147483647 -9223372036854775808~~9223372036854775807 0~~255 -3.4E38~~3.4E38 -1.7E308~~1.7E308 True~~false 整数类型（byte；short；int；long） 浮点类型（float；double） 设置数据的时候，注意要设在允许的范围之中。如果设置的数值超过了范围就会出现数值不正确的情况。

实例3：Psychopath.java

目标：实现一个变态长度数字的输出结果并观察错误。 文件名：Psychopath.java 文件路径：E:\\java\\2

学习内容：数据的取值范围 代码内容： public class Psychopath{ public static void main(String args[]){ int num = 11111111111111111111111111111111111111111111 ; }; } 上面这个num的值明显超过了int的取值范围，当一个数值已经在最大值或最小值时，再进行增加或减少的操作，就会出现数据溢出现象。通过下面一个小例子来观察数据溢出的现象。

实例4：Overflow.java

目标：实现一个长度溢出数字的输出结果并观察错误。 文件名：Overflow.java 文件路径：E:\\java\\2

学习内容：数据的取值范围 代码内容： public class Overflow{ public static void main(String args[]){ }; } int max = Integer.MAX_VALUE ; // 求出整型的最大值 System.out.println(\整型的最大值：\System.out.println(\整型的最大值 + 1：\System.out.println(\整型的最大值 + 2：\观察输出的结果： E:\\java\\2>java Overflow 整型的最大值：2147483647 整型的最大值 + 1：-2147483648 整型的最大值 + 2：-2147483647 最大值正常输出，加上1以后却变成了最小值，这是闹哪样？（此处随机抽人解答） 最大值加上2，输出是最小值再加1，通过观察结果，熟悉取值的范围。

课堂练习：随机一人，自行编写最小值减1的代码。一次不成功者，男生五个俯卧撑，女生五次抱头下蹲，换一人改错，一次不成功者类推。 在程序编写过程中，如果出现需要扩大数值范围的情况，可以采用改变数据类型的方式来解决；将Overflow.java中max更改为(long)max，再观察输出结果，还会有溢出现象吗？ 字符数据类型：用来保存数字、字母、符合等数据，计算机在处理字符型数据时，是把它当成不同的整数来看待的，可以说字符型是特殊的整型数据。通过下面的小例子来观察一下： 实例5：Chardemo.java

目标：实现通过整型数字定义字符的输出结果。 文件名：Chardemo.java 文件路径：E:\\java\\2 学习内容：字符型数据 代码内容： public class Chardemo{ public static void main(String args[]){ char ch1 = 'a' ; // 字符是使用”'“括起来的数据 char ch2 = 97 ; // 通过数字定义字符变量 System.out.println(\System.out.println(\ }; } 观察输出的结果：

E:\\java\\2>java Chardemo ch1 = a ch2 = a 既然如此，那我们就来试试用数字来输出字符，如果能成功，那恭喜你可以做谍报人员了。 课堂练习：随机一人，自行编写将数字（73、32、108、111、118、101、32、121、111、117、32、97、108、108、33）转成字符输出的代码。一次不成功者，男生五个俯卧撑，女生五次抱头下蹲，换一人改错，一次不成功者类推。 有些转义字符需要了解： 转义字符 \\f \\r \\\\ \\” 描述 换页 归位 反斜线 双引号 转义字符 \\b \\t \\’ \\n 描述 倒退一格 Tab 单引号 换行 课后练习：将表内转义字符输出。 单精度、双精度型数据：在用到小数时，需要使用单精度型数据或双精度型数据。通过下面的小例子来学习一下： 实例6：Floatdemo.java

目标：实现两个单精度型数字相乘的输出结果。 文件名：Floatdemo.java 文件路径：E:\\java\\2 学习内容：单精度型数据 代码内容： public class Floatdemo{ public static void main(String args[]){ }; } float num = 3.0; // 定义一个单精度型变量 System.out.println(\两个小数相乘：\观察结果，错误提示为： E:\\java\\2>javac Floatdemo.java Floatdemo.java:3: 可能损失精度 找到： double 需要： float float num = 3.0; // 定义一个单精度型变量 ^ 1 错误 问题出在数值都是有默认值的，像123这些整数默认为int型，而1.1这些小数默认为double型的。所以要将代码修改一下，明确小数定义的类型。 float num = 3.0; // 定义一个单精度型变量 float num = 3.0f; // 定义一个单精度型变量 修改为 就没有问题了。开发中用个float基本就够了，一般用不着double那么大的数字。

布尔型数据：只有两个值，true和false。对，你没有看错，只有两个值。不像别的语言，比如c，可以用0和1来表示真假，java只能用true和false。定义一个值为布尔型时，可以用下面的代码来实现。 boolean flag=true; Java的数值类型是强性的，使用时就定义好了，不能想咋样就咋样，不过java还是网开一面，允许我们进行有限的类型转换处理。方式有自动类型转换和强制类型转换两种。 自动类型转换：符合以下两个条件，则进行自动类型转换 转换前的数据类型与转换后的类型兼容； 转换后的数据类型表示范围比转换前的大； 例如： int x = 10 ; // 定义整型变量 float y = 22.22f ; // 定义浮点型变量 System.out.println(\ //自动转换成浮点型，因为浮点型比整型范围大。 System.out.println(\自动转换成double，默认类型分别是int和double。 System.out.println(\默认类型都是int，输出也是int 数值和字符串在一起，会自动改变为字符串，例如： String str = \ int x = 100 ; // 定义字符串变量 str = str + x ; // 修改str的内容并将内容重新赋给str变量 System.out.println(\int i = 1 ; // 定义整型变量 int j = 1 ; // 定义整型变量 System.out.println(\System.out.println(\字符串类型是所有数据类型最终的归宿，思考一下，这个代码输出是什么？ 上面的实例中10/3的输出是3，小数部分被忽略掉了，要是输出出来怎么整？这就需要强制类型转换。 强制类型转换：（要转换成的数值类型）变量名称 那上面的代码改成： System.out.println(\（float）10 /3)) ; //默认类型都是int，输出强制转换成float 5 Java中的运算符

掌握赋值运算符的使用 掌握算术运算符的使用 掌握条件运算符的使用 掌握逻辑运算符的使用 掌握位运算符的使用

掌握递增、递减运算符的使用 掌握括号运算符的使用 掌握各个运算符的优先级

Java语句中表现形式有很多种，表达式是重要的组成部分。表达式是有操作数和运算符组成，操作数可以是常量、变量或者是方法；运算符就是各种运算的符合，如+、-、*、/、%等等，例如下面的表达式，i和1就是操作数，+=就是操作符。 I+=1; Java运算符根据操作数分为一元、二元、三元运算符。 5.1 赋值运算符

运算符 = += -= /= %

数学含义 赋值 相加赋值 相减赋值 相除赋值 取模赋值

示例 i=j i+=j i-=j i/=j i%=j

赋值运算符为一个“=”，表示将一个值赋给变量。

5.2 算术运算符

运算符 + - * / % ++ --

数学含义 加

减/负号 乘 除 取模 自增 自减

示例 i+j i-j；-i i*j i/j i%j i++ i--

算术运算符的使用与数学运算一样，通过下面的小例子来熟悉一下。 实例7：Arithmetic.java

目标：实现两个变量算术运算的输出结果。 文件名：Arithmetic.java 文件路径：E:\\java\\3 学习内容：算术运算符 代码内容：

public class Arithmetic{ public static void main(String args[]){ int i = 10 ; int j = 3; System.out.println(i + \加法操作 System.out.println(i + \// 减法操作 System.out.println(i + \// 乘法操作 System.out.println(i + \加法操作 System.out.println(i + \// 取模操作 System.out.println(\// 自增操作 System.out.println(\// 自减操作 } }; 运行结果为：

E:\\java\\3>java Arithmetic 10 + 3 = 13 10 - 3 = 7 10 * 3 = 30 10 / 3 = 3 10 % 3 = 1 i++ = 10 i-- = 11 5.3 比较运算符：

运算符 > < == != >= <=

比较运算符的作用和数学运算相同，得到的结果为布尔型数据，通过下面的小例子来熟悉一下。

实例8：Compare.java

目标：实现两个变量比较运算的输出结果。 文件名：Compare.java 文件路径：E:\\java\\3 学习内容：比较运算符 代码内容：

public class Compare{ public static void main(String args[]){ System.out.println(\// 使用大于号 System.out.println(\// 使用小于号 System.out.println(\// 使用大于等于号 System.out.println(\// 使用小于等于号 System.out.println(\// 使用等于号 System.out.println(\使用不等于号 数学含义 大于 小于 等于 不等于 大于等于 小于等于

示例 i>j i=j i<=j

}; } 运行结果为：

E:\\java\\3>java Compare 3 > 1 = true 3 < 1 = false 3 >= 1 = true 3 <= 1 = false 3 == 1 = false 3 != 1 = true 5.4 逻辑运算符

运算符 | & ！ || && ^

数学含义 或 与 非 短路或 短路与 异或

示例 i|j i&j ！i i||j i&&j i^j

逻辑运算符运行在布尔表达式中，遵循真值表规则。与同真为真，或同假为假，短路与前面成立看后面，短路或前面不成立看后面，异或不同为真，注意，不管短路还是不短路，其结果是一样的。通过一个小例子来熟悉一下。 实例9：Logic.java

目标：实现两个变量逻辑运算的输出结果。 文件名：Logic.java 文件路径：E:\\java\\3 学习内容：逻辑运算符 代码内容： public class Logic{ public static void main(String args[]){ boolean i = true ; boolean j = false ; System.out.println(\ System.out.println(\ System.out.println(\ System.out.println(\ System.out.println(\ System.out.println(\ System.out.println(\ } }; 运行的结果：

E:\\java\\3>java Logic i || j = true i | j = true i && j = false i & j = false ! i = false ! j = true i ^ j = true 5.5 位运算符：

运算符 | & ~ >> >>> << ^

数学含义 按位或 按位与 按位非 右移位 无符号右移 左移位 按位异或

示例 i|j i&j ~i i>>j i>>>j I<

位运算直接对整数类型的位进行操作，byte、short、int、long，char作为特殊的整型数据，也可以进行位运算。计算机中所有的整数类型都是以二进制数字位的变化及其宽度来表示的。例如，byte类型是8位，那byte类型的48，即可表示为0110000。

&：按位与，对两个操作数逐位进行与操作，例如，00101010&00001111=00001010 |：按位或，对两个操作数逐位进行或操作，例如，00101010|00001111=00101111 ~：按位非，是对其操作数的每一位取反，~0110000=1001111

^：按位异或，对两个操作数逐位进行异或操作，例如，00101010^00001111=00100101 >>：右移，前面的操作数移动后面的操作数个位，最右边溢出的数丢失，最左边空出的位由原来的数补充，例如，11111000>>1=11111100

>>>：无符号右移，前面的操作数移动后面的操作数个位，最右边溢出的数丢失，最左边空出的位由0补充，例如，11111000>>>1=01111100

<<：左移，前面的操作数移动后面的操作数个位，最左边溢出的数丢失，最右边空出的位由0补充，例如，11111000<<1=11110000

5.6 条件运算符

条件运算符是三元运算符，格式为<表达式>?e1：e2。其中表达式的值为布尔型数值，为真时返回e1的值，为假则返回e2的值。

5.7 运算符的优先级和括号运算符

在多个运算符同时出现的表达式中，按运算符的优先级由高到低进行运算，这个优先级是个

很无趣的东西，不需要去记住它，因为常用的与数学运算是一致的，不常用的，查表即可，并且括号运算符中的表达式是优先执行的，可以通过括号来改变运算顺序。

6 判断与循环语句

掌握程序的三种结构 掌握选择语句的使用 掌握循环语句的使用

掌握break、continue关键字的使用

6.1 程序的结构

顺序结构、选择结构、循环结构 顺序结构：程序从头到尾逐句执行。

选择结构：程序根据条件判断满足条件的分支语句并执行。 循环结构：程序根据条件判断满足条件的循环语句并执行。

6.2 选择结构

常用的语句有if、if—else、if—elseif—else来判断。

若是在多个选择项中选择一种情况执行，可以使用switch语句来简化。Switch语句中使用数字或字母做选择项。 实例9：Swithdemo.java

目标：实现五分制成绩输出。 文件名：Swithdemo.java 文件路径：E:\\java\\4 学习内容：switch语句 代码内容：

public class Switchdemo{ public static void main(String args[]){ int score=20; int flag=0; if(score<20&&score>0){ flag=1; }else if(score>=20&&score<40){ flag=2; }else if(score>=40&&score<60){ flag=3; }else if(score>=60&&score<80){ flag=4;

}else if(score>=80&&score<100){ flag=5; }else{ flag=6; } switch(flag){ case 1: System.out.println(\ break; case 2: System.out.println(\ break; case 3: System.out.println(\ break; case 4: System.out.println(\ break; case 5: System.out.println(\ break; default: System.out.println(\成绩无效！\ } } } 试一下，把程序中的break去掉，看看输出的情况，体会break的作用。

6.3循环结构

循环执行某个代码块，循环多少次，要取决于循环条件满足多少次。常用形式为while、do-while、for结构。 实例10：Whiledemo.java

目标：实现while结构循环输出1到100的累加。 文件名：Whiledemo.java 文件路径：E:\\java\\4 学习内容：while语句 代码内容： public class Whiledemo{ public static void main(String args[]){ int num=0; // 定义一个变量sum，用来保存累加的结果 int i=1; while(i<=100){ num+=i; i++; } System.out.println(\到100的累加和是：\ } } 实例11：DoWhiledemo.java

目标：实现do-while结构循环输出1到100的累加。 文件名：DoWhiledemo.java 文件路径：E:\\java\\4 学习内容：do-while语句 代码内容： public class DoWhiledemo{ public static void main(String args[]){ int num=0; // 定义一个变量sum，用来保存累加的结果 int i=1; do{num+=i; i++; } while(i<=100); System.out.println(\到100的累加和是：\ } } 对于不怎么明确循环次数的使用while或者do-while，如果知道明确的循环次数，还是用for循环语句更方便。 实例12：Fordemo.java

目标：实现for结构循环输出1到100的累加。 文件名：Fordemo.java 文件路径：E:\\java\\4 学习内容：for语句 代码内容： public class Fordemo{ }; // 完成一个for循环，计算100的累加 public static void main(String args[]){ } int sum = 0 ; // 定义一个变量sum，用来保存累加的结果 for(int i=1;i<=100;i++){ sum += i ; } System.out.println(\到100 累加的结果为：\For循环经常嵌套使用，比如淘淘在背九九乘法表，要是输出一个乘法表，就用两个for循环，一个控制行，一个控制列。如下

实例13：Fordemo2.java

目标：实现for结构循环输出九九乘法表。 文件名：Fordemo2.java 文件路径：E:\\java\\4 学习内容：for语句嵌套 代码内容：

public class Fordemo2{ }; // 完成一个九九乘法表的功能 public static void main(String args[]){ } for(int i=1;i<=9;i++){ // 控制行 for(int j=1;j<=9;j++){ // 控制列 System.out.print(i+\ } } System.out.println() ; // 空输出，用来换行 输出的结果为： E:\\java\\4>java Fordemo2 1*1=1 1*2=2 1*3=3 1*4=4 1*5=5 1*6=6 1*7=7 1*8=8 1*9=9 2*1=2 2*2=4 2*3=6 2*4=8 2*5=10 2*6=12 2*7=14 2*8=16 2*9=18 3*1=3 3*2=6 3*3=9 3*4=12 3*5=15 3*6=18 3*7=21 3*8=24 3*9=27 4*1=4 4*2=8 4*3=12 4*4=16 4*5=20 4*6=24 4*7=28 4*8=32 4*9=36 5*1=5 5*2=10 5*3=15 5*4=20 5*5=25 5*6=30 5*7=35 5*8=40 5*9=45 6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 6*7=42 6*8=48 6*9=54 7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 7*8=56 7*9=63 8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 8*9=72 9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81 这样的九九乘法表与我们见过的阶梯状输出不同，思考一下，要是改成标准的九九乘法表，应该把程序做哪些改动呢？随机提问，回答错误或不知道的男生五个俯卧撑，女生五次抱头下蹲。

Break语句，用来执行中断当前的循环语句，执行循环外的语句，若是在内嵌套的循环中使用break，则跳出内嵌套，继续执行外嵌套的语句。 实例14：Breakdemo.java

目标：实现for结构循环中使用break语句完成中断。 文件名：Breakdemo.java 文件路径：E:\\java\\4 学习内容：break中断 代码内容： public class Breakdemo{ public static void main(String args[]){ for(int i=0;i<10;i++){ if(i==5){ break ; }; } } } System.out.println(\执行结果如下： E:\\java\\4>java Breakdemo i = 0 i = 1 i = 2 i = 3 i = 4 Continue语句，用来执行中断一次当前的循环语句，回到当前循环语句的开始继续执行。 实例15：Continuedemo.java

目标：实现for结构循环使用continue语句中断。 文件名：Continuedemo.java 文件路径：E:\\java\\4 学习内容：continue中断 代码内容： public class Continuedemo{ public static void main(String args[]){ for(int i=0;i<10;i++){ if(i==5){ continue ; } System.out.println(\ } } }; 运行结果如下： E:\\java\\4>java Continuedemo i = 0 i = 1 i = 2 i = 3 i = 4 i = 6 i = 7 i = 8 i = 9 7 数组

掌握数组的作用

掌握数组的声明及内存分配 掌握数组的操作

了解多维数组的定义及操作

7.1 数组是什么

数组是一组相关变量的集合。一连串相同类型的变量集合为一个整体，就是一个数组。 数组安装使用方式不同可以分为一维数组、二维数组、多维数组。

7.2 使用数组的优势

如果我们定义一百个整型变量，需要写成int i1;int i2; int i3……int i100; 使用数组的话，写一个就行了，int i[100];

7.3 一维数组

一维数组里面可以存放不限数量的变量，这些变量必须类型严格一致。

一维数组的定义是先声明数组，然后分配堆内存给该数组。声明的方式有两种： 声明方式一： 数组类型 数组名 []=null; 数组名=new 数据类型[长度]; 声明方式二： 数组类型 [] 数组名=null; 声明的数据类型是数组内数据的类型，如整型，浮点型，字符型。数组名为这一组相同数据类型的数据集合名称。数组的声明是在栈内存中保存数组的名称，要使用该数组必须在堆内存中开辟一块空间并分配给数组。开辟空间的关键字为new。

开始的时候我们说过，java数据类型分两类，基本数据类型和引用数据类型（数组、类、接口）。引用传递的是内存的使用权。

栈内存 Array int array []=null; null

array=new int[10];

堆内存 0 (array[0]) 0 (array[1]) 0 (array[2]) 0 (array[3]) … 0 (array[9]) 实例16：Arraydemo.java

目标：定义一个数组，并输出数组内容。 文件名：Arraydemo.java 文件路径：E:\\java\\5 学习内容：数组的定义 代码内容：

public class Arraydemo{ public static void main(String args[]){ }; } int array[] = null ; // 声明数组 array = new int[10] ; // 为数组开辟空间，大小为10 System.out.println(\ // 依次输出数组内容 System.out.println(\System.out.println(\System.out.println(\System.out.println(\System.out.println(\System.out.println(\System.out.println(\System.out.println(\System.out.println(\for(int i=0;i<10;i++){ } System.out.println(\ // 循环输出数组内容 运行结果为： E:\\java\\5>java Arraydemo array[0] = 0 array[1] = 0 array[2] = 0 array[3] = 0 array[4] = 0 array[5] = 0 array[6] = 0 array[7] = 0 array[8] = 0 array[9] = 0 7.4 栈内存与堆内存的理解：

栈内存 张三 小张 小三 胖三 。。。 在栈内存中，保存的是数组的名称，只有一个名称的数组是无法使用的，比如我们知道一个人叫张三，但是不知道这个人是谁，无法落实一个实体。堆内存中开辟一块空间保存一个人，这个人由数组名称指定，比如叫张三。可以由多个数组名指定一个实体，这个叫张三的人，也可以叫小张，小三，胖三等等。

在声明数组的同时也可以接着分配空间： int array[] = new int[10] ; 这句话的含义就是声明一个数组，数组名为array，数组类型为int，数组大小为10. Int型的数据大小为32位，也就是4b，这样在堆内存中同时开辟了4b*10=40b的大小保存这个名为array的数组： Array 4b 4b 4b 4b 4b 4b 4b 4b 4b 4b 在数组输出的时候，如果下标超出了数组的范围，则会提示出错，错误类型为数组越界异常。 获取数组的长度时，可以取其长度属性来获取。数组名.length。

堆内存 7.5 数组的赋值

对数组进行赋值有两种方式，静态赋值和动态赋值。 静态赋值是在声明的时候直接写出数组的值： Int array []={1,2,3,4,5,6,7,8,9,10}； 动态赋值是利用循环为每一个元素赋值。

赋值之后，就可以进行一些操作，比如比较大小，排序等等 比较大小： int max = 0 ; int min = 0 ; max = min = array[0] ; for(int i=0;imax){ max = array[i] ; } if(array[i]

for(int i=1;i

二维数组：数组中的元素也是数组。二维数组的声明方式为： int array[][] = new int[4][3]； 8 方法的声明与使用

掌握方法的作用以及使用格式 掌握方法重载的意义与使用 了解使用return结束一个方法 掌握方法的递归调用

8.1 方法是什么

方法就是一组代码，可以重复调用。如果程序中需要多次调用一段代码，或者说多次编写同样的一段代码，这样的话，编写起来很麻烦，并且修改的时候更悲催，这个时候就需要把这段固定的代码框起来，约束为一个方法，以供程序反复调用，更改的时候只需要更改方法本身就完事了。 使用格式为：

Public static 返回值类型 方法名称（参数类型 参数1 参数类型 参数2…）{ 方法主体 （return） } 实例17：Methoddemo.java

目标：定义一个方法，并在主方法中调用它。 文件名：Methoddemo.java 文件路径：E:\\java\\6 学习内容：方法的使用 代码内容： public class Methoddemo{ public static void main(String[] args){ printinfo(); printinfo(); printinfo(); printinfo(); printinfo(); } public static void printinfo(){ System.out.println(\再不疯狂，我们就老了\ } } 运行结果： E:\\java\\6>java Methoddemo 再不疯狂，我们就老了 再不疯狂，我们就老了 再不疯狂，我们就老了 再不疯狂，我们就老了 再不疯狂，我们就老了 在这个实例中，printinfo（）方法只写了一次，在主方法中调用了5次，只要你愿意，调用n次也无妨，修改的时候只需要把printinfo（）修改一下即可，真是方便。

程序中调用方法的时候，执行该方法，待该方法执行完毕后，返回调用处继续执行。 如果调用的方法有返回值，则使用return关键字来返回。 实例18：Methoddemo2.java

目标：定义一个方法，并使用return返回值。 文件名：Methoddemo2.java 文件路径：E:\\java\\6 学习内容：return的使用 代码内容： public class Methoddemo2{ public static void main(String args[]){ } int one = addOne(10,20) ; // 调用整型的加法操作 float two = addTwo(10.3f,20.3f) ; // 调用浮点数的加法操作 System.out.println(\调用addOne方法的计算结果：\System.out.println(\调用addTwo方法的计算结果：\// 定义addOne方法，完成两个数字的相加操作，方法返回一个int型数据 public static int addOne(int i,int j){ } int temp = 0 ; temp = i + j ; return temp ; // 方法中临时使用的参数，是局部变量 // 执行加法计算 // 返回计算结果 // 定义addTwo方法，完成两个数字的相加操作，方法的返回值是一个float型数据 public static float addTwo(float i,float j){ float temp = 0 ; temp = i + j ; // 方法中临时使用的参数，是局部变量 // 执行加法操作 }; } return temp ; // 返回计算结果 运行结果为： E:\\java\\6>java Methoddemo2 调用addOne的计算结果：30 调用addTwo的计算结果：30.599998 在此实例中定义了两个加法的方法addOne和addTwo，一个返回整型，一个返回浮点型。在定义这两个方法的时候，就要明确返回值的类型int和float，切记，否则会出错。

8.2 方法的重载

在上面的实例当中，我们发现addOne和addTwo两个方法其实完成的是一个活，就是两个变量相加返回一个值。那我们把one和two去掉，都命名为add方法，调用add方法时，根据参数的数据类型来选择用哪个add方法行不行呢？ 当堂测试。。。

测试的结果是一致的，说明这个想法可行。当我们定义了多个方法名相同的方法，其参数类型、参数个数不同，通过传递不同的参数来完成不同的功能，这个过程就叫做方法的重载。 寻找一个没在听课的孩子，要求其修改完成下面代码的输出，同上，完成不了的汉子五个俯卧撑，妹子五次抱头下蹲。 int one = add(10,20) ; float two = add(10.3f,20.3f) ; int three = add(10,20,30) ; float four = add(10.3f,20.3f,30.3f) ; 通过上面这个实例我们可以看出，add方法被重复使用了4次，但这4次都是调用的不同的方法，根据参数类型或个数不同，自动选择调用了不同的方法。其实，大家回想一下，我们一直在使用的System.out.println（），想输出啥就输出啥，这就是方法的重载，其实重载一直默默的守护在我们身边，只是我们缺少那一次回眸，发现它的存在而已。

方法重载只需要注意一个地方，只是参数类型、参数个数不同，否则就不能说是重载。

8.3 Return

在上面的例子当中，我们使用到了return，这是结束当前的方法，返回到调用方法的地方继续执行，那么，在被调用的方法中，return之后能不能写代码，写了代码能不能被执行到。 找个妹子或汉子回答，并将代码修改如下进行测试。 实例19：Returndemo.java 目标：使用return。

文件名：Returndemo.java 文件路径：E:\\java\\6

学习内容：加入return之后代码的执行顺序 代码内容： public class Returndemo{ public static void main(String args[]){

}; System.out.println(\、调用ret()方法之前。\ret(1) ; System.out.println(\、调用ret()方法之后。\} public static void ret(int i){ } System.out.println(\、进入ret()方法。\if(i==1){ } return ; // 结束当前方法，返回被调用处。 System.out.println(\、正常执行完ret()方法。看看能不能出来\运行结果如下： E:\\java\\6>java Returndemo 1、调用ret()方法之前。 3、进入ret()方法。 2、调用ret()方法之后。 这样我们就可以得出结论，在return之后的第四句话，不能被输出出来，因为在它前面的return中已经结束了当前的调用。

8.4 方法的递归调用

方法的递归调用是一种特殊的使用方式，就是方法自己调用自己。比如我对自己说，要吃饭，当我满足条件，就是肚子还有空，那就吃，当我不满足条件，肚子没地了，就停止调用要吃饭的指令，停止吃饭的方法。这个吃饭的指令其实是我对自己下达的，这就是方法的递归调用。

实例20：Recursion.java

目标：使用方法的递归运算斐波那契级数。 文件名：Recursion.java 文件路径：E:\\java\\6

学习内容：用户输入一个数值，运算出这个值的斐波那契级数 代码内容：

public class Recursiondemo{ public static void main(String args[]){ int temp; //定义一个整型变量，表示第i项的值 int i; //定义一个整型变量，表示第i项 java.util.Scanner s=new java.util.Scanner(System.in); //获取用户输入值 i=s.nextInt(); //接收一个整型字符 temp=rec(i); System.out.println(\第\项斐波那契级数为：\ } public static int rec(int i){ if(i==1||i==2){ return 1; // 前两项都是1 } return rec(i-1)+rec(i-2); } } 运行结果如下： E:\\java\\6>java Recursiondemo 10 第10项斐波那契级数为：55 注意，在使用递归的时候，必须有明确的方法结束判断或有明确的范围，否则会出现内存溢出，也就是说，计算机让你活活的累死了。

上面说的是主方法调用方法，那么方法能调用方法吗，这就是方法的引用传递，在后面再去学习。

8.5 使用方法传递数组

使用方法可以接收和返回一个数组，若是一个方法接收了一个数组，那么此方法对数组所做的操作就会全部保存下来。通过一个实例来学习一下： 实例21：Arraydemo.java

目标：使用方法接收一个数组，并作出修改。 文件名：Arraydemo.java 文件路径：E:\\java\\6

学习内容：使用方法接收数组 代码内容： public class Arraydemo{ public static void main(String args[]){ }; } int temp[] = {1,3,5,7,9} ; // 利用静态初始化方式定义数组 fun(temp) ; // 传递数组,使用fun方法接收这个数组 for(int i=0;ijavac Arraydemo.java E:\\java\\6>java Arraydemo 6、3、5、7、9、 此实例中静态定义了数组temp之后，使用一个fun（）方法来接收，方法体中存在修改的操作，所以接收以后的数组也就被修改了，数组输出的结果是经过方法修改之后的结果。 画个小图，帮助理解：

栈内存 Temp[] 堆内存 Temp[0]=1 Temp[1]=3 Temp[2]=5 Temp[3]=7 栈内存 Temp[] X[] 堆内存 Temp[0]=1 Temp[1]=3 Temp[2]=5 Temp[3]=7 栈内存 Temp[] X[] 堆内存 Temp[0]=6 Temp[1]=3 Temp[2]=5 Temp[3]=7 栈内存 Temp[] X[] 堆内存 Temp[0]=6 Temp[1]=3 Temp[2]=5 Temp[3]=7

再来看看怎么用方法返回数组，既然是返回，那么返回值类型必然是数组类型，方法体中给出返回之后的情况，也就是说使用此方法来定义该数组。用个实例来说明： 实例22：Arraydemo2.java

目标：使用方法返回一个数组，并输出数组内容。 文件名：Arraydemo2.java 文件路径：E:\\java\\6

学习内容：使用方法返回数组 代码内容：

public class Arraydemo2{ public static void main(String args[]){ }; } int temp[] = fun() ; print(temp) ; // 通过fun方法实例化数组 // 这里嘚瑟一下，用一个方法接收该数组完成打印 public static void print(int x[]){ //定义print方法接收数组 for(int i=0;i

这个地方多做一些练习，把数组的排序弄成一个方法，需要的时候就直接调用： 实例23：Arraydemo3.java

目标：使用方法接收返回一个数组，并对数组排序。 文件名：Arraydemo3.java

文件路径：E:\\java\\6

学习内容：使用方法接收返回数组 代码内容： public class Arraydemo3{ public static void main(String args[]){ }; } int score[] = {67,69,87,79,90,100,75,92} ; // 定义整型数组表示成绩 int age[] = {31,30,28,27,18,19,17,32} ; // 定义整型数组表示年龄 sort(score) ; // 使用sort方法接收数组排序 print(score) ; // 使用print方法对数组打印 System.out.println(\方法先调用，所以打印的是排序后的数组---\ sort(age) ; // 使用sort方法接收数组排序 print(age) ; // 使用print方法对数组打印 // 定义一个sort方法执行排序操作 public static void sort(int temp[]){ for(int i=1;ijava Arraydemo3 67 69 75 79 87 90 92 100 ---sort方法先调用，所以打印的是排序后的数组--- 17 18 19 27 28 30 31 32 在程序中，一个方法排序，一个方法输出，都是对数组的操作。其实java对数组的操作是有固定的包可以直接拿来用的，现在是学习阶段，不用考虑那些省事的东西了，老老实实的把程序思路练顺畅，比啥都强。

8.6 使用方法复制数组

使用方法来复制一个数组的全部或局部内容，这个方法需要的参数有点多，既然要复制，就要有一个源数组，一个目标数组，从哪里开始复制，就需要有源数组的开始点和目标数组的开始点，那么你要复制，需要复制多少，还需要一个复制的长度。

总计：源数组、源数组开始点、目标数组、目标数组开始点、复制长度。 按照这个思路，我们来完成一个数组的复制任务。 实例24：Arraydemo4.java 目标：使用方法复制数组。 文件名：Arraydemo4.java 文件路径：E:\\java\\6

学习内容：使用方法复制一个数组内容给另外一个数组 代码内容： public class Arraydemo4{ public static void main(String args[]){ } } int source[] = {1,2,3,4,5,6,7,8,9} ; //定义一个源数组 int target[] = {11,22,33,44,55,66,77,88,99} ;//定义一个目标数组 copy(source,3,target,3,3) ; // 调用复制方法 print(target) ; // 输出目标数组 // 源数组名称，源数组开始点，目标数组名称，目标数组开始点，复制长度 public static void copy(int s[],int len1,int t[],int len2,int len3){ for(int i=0;ijava Arraydemo4 11 22 33 4 5 6 77 88 99 对于数组的操作，一定要切实理解传递的是数组的使用权，在调用的时候不用加[]，直接给出数组的名称即可。

9 面向对象

在这部分内容中，介绍了java的核心内容，掌握以下内容： 了解面向对象的基本概念 了解面向对象的三个主要特征 掌握类与对象的关系 掌握类的定义

掌握对象的声明与使用

9.1 什么是面向对象

程序经历了两个方式：面向过程、面向对象。

面向过程是看重程序的过程，遇到什么问题解决什么问题；

面向对象是看重程序的分析，先把成型之后的程序设计好，再把问题分解开，一个部分一个部分的解决。

面向对象的三个特征：封装、继承、多态

封装性：将对象的属性和方法都隐藏起来，对外不可见，起到对程序的保护作用。 继承性：扩展类的功能，并省去了很多重复性的劳动。 多态性：方法的重载、对象的多态。

类与对象的关系是java中最重要的部分，想学习java就必须把类与对象的关系弄清楚。 类：是一个抽象的描述，是概念性的，对一些具有相同属性和行为的事物的综合描述。比如说人类。是人类，就有姓名、性别、年龄、身高、体重、国籍等等共同的属性，也有吃喝拉撒睡共同的行为。

对象：是一个类中的具体的一个个体。比如张三是一个学生，李四是一个职员，王五是一个士兵。

类是不能直接使用的，必须实例化一个实体，也就是对象，才能使用。我可以让张三站起来，但是不能让人类站起来。

概况一点，就是说类是相同属性对象的集合，对象是类的具体实例，类是一个标准，设计的对象都符合这个标准。

类和对象都有其固定的格式，比如说定义一个人类，用class关键字一修饰就行： class Person{} 然后是属性，比如姓名和年龄，定义两个变量就行了： String name ; int age ; // 表示姓名 // 表示年龄 还有方法，比如吃喝，定义这两个方法： public void eat(){} public void drink(){} 这样就完成了一个类的定义。

要使用这个类，必须有一个实例化的对象，格式为： 类名 对象名=null； //声明对象 对象名=new 类名（）； //实例化对象 类名 对象名= new 类名（）； //这是写到一起的格式 与上面类对应起来，可以这样实例化一个对象： Person per=new Person（）； 这样一来，per作为一个具体的人，就可以使用了。 在程序开发中，一个类用类图来标识这些属性和方法： Person name：String age：int + eat（）：void + drink（）：void 第一层写类名，第二层写属性，第三层写方法，有个+标识访问权限。 Person per = new Person（）；

声明对象，在栈内存中。 栈内存 Per

实例化对象，堆内存中。 堆内存 Name=null Age=0 在开发中最好还是分着写，不容易报错。实例化之后就可以对对象属性进行赋值了，也可以使用对象调用方法，比如： per.name=”张三”; per.age=30; per.eat(); per.drink(); 我们来把这个程序写全，看看效果如何： 实例25：Classdemo.java 目标：使用对象。

文件名：Classdemo.java 文件路径：E:\\java\\7

学习内容：定义对象属性和方法 代码内容： class Person{ String name ; // 声明姓名属性 int age ; // 声明年龄属性 public void eat(){ // 定义吃方法 System.out.println(\姓名：\，年龄：\，调用了吃方法。\} public void drink(){ // 定义喝方法 System.out.println(\姓名：\，年龄：\，调用了喝方法。\ } } public class Classdemo{ public static void main(String args[]){ //Person per = new Person() ; // 创建并实例化对象，开发中最好分着写，如下： Person per = null ; // 声明对象 per = new Person() ; // 实例化对象 per.name=\张三\ // 为per的name属性赋值 per.age=30; // 为per的age属性赋值 per.eat(); // 为per调用吃方法 per.drink(); // 为per调用喝方法 } } 运行结果如下：

E:\\java\\7>java Classdemo 姓名：张三，年龄：30，调用了吃方法。 姓名：张三，年龄：30，调用了喝方法。 如果在代码中没有去实例化per对象，试一下出现了什么，是一个空指向异常，记住这个异常，因为它会经常与我们约会的。

根据对象的格式，我们为person类多实例化几个对象，然后再去调用属性和方法，寻找个汉子或妹子，把宿舍人员全部输出出来。

考虑一个问题，就是两个对象指向一个空间地址的情况，如：per2=per1；分析一下栈内存和堆内存的指向情况。 栈内存 Per1 Per2 堆内存 Name=张三 Age=30 栈内存 Per1 Per2 堆内存 Name=张三 Age=30

再考虑一个问题，就是两个对象分别实例化之后，再出现per2=per1，分析一下情况。 栈内存 Per1 Per2 堆内存 Name=张三 Age=30 Name=李四 Age=40 栈内存 Per1 Per2 堆内存 Name=张三 Age=30 Name=李四 Age=40 在这里出现了name=李四，age=40的这段空间没有对象引用了，既然占着地方不干活，这就变成了一个垃圾空间，等待java的垃圾回收机制进行回收，数据就丢失了。

9.2 java三大特性之封装性

为什么要进行封装呢？

封装就如同我们的皮肤和肌肉，保护着内脏一个道理，如果没有皮肤和肌肉，别人想拿走你的肾脏，只需要拿手一拽就行了。Java也是一样，对象的属性方法如果不保护起来，别人岂不是想调用什么就能调用什么，还有什么安全可言呢。封装之后，对象的属性和方法是对外不可见的。 怎么实现封装？

可以使用下面的方式对对象的属性和方法进行封装： Private 属性类型 属性名称 Private 方法返回值 方法名称（参数。。。）{} 我们把实例25修改一下，将person类的属性改成： Private String name ; // 声明姓名属性 Private int age ; // 声明年龄属性 然后再运行一次，这次看到了什么呢，在per对象对属性赋值的时候，无法对封装的属性进行访问了。

怎么访问封装的内容呢？

这些属性我们是要拿来用的，不能访问是肯定不行的，要访问封装之后的属性，就要使用seter（）和geter（）方法来完成。

Seter（）方法是设置属性；geter（）方法是访问属性。比如上面的name属性，就应该写成： Public static void setName（String n）{} Public String getName（）{} 注意name中的n是要大写的，因为方法的命名规则，首字母小写，后面每个单词首字母大写。我们来把实例25都改写完，就变成了下面的实例26： 实例26：Packagedemo.java 目标：对象的封装性。

文件名：Packagedemo.java 文件路径：E:\\java\\7

学习内容：使用封装方式定义对象属性和方法 代码内容： class Person{ private String name ; // 声明姓名属性 private int age ; // 声明年龄属性 public void setName(String n){ // 设置姓名 name = n ; } public void setAge(int a){ age = a ; } public String getName(){ return name ; } public int getAge(){ return age ; } // 设置年龄 // 取得姓名 // 取得年龄 public void eat(){ // 定义吃方法 System.out.println(\姓名：\，年龄：\，调用了吃方法。\} public void drink(){ // 定义喝方法 System.out.println(\姓名：\，年龄：\，调用了喝方法。\} } public class Packagedemo{ public static void main(String args[]){ Person per = new Person() ; // 声明并实例化对象 per.setName(\张三\ // 调用setter设置姓名 per.setAge(30) ; // 调用setter设置年龄 per.eat(); // 为per调用吃方法 per.drink(); // 为per调用喝方法 } } 运行一下，看到输出跟前面实例25一样的。 如果要对属性的范围进行限制的话，直接加到seter()方法中即可，假如我们将年龄的范围设置在0-150之间，那么把下面这个条件加进去就完成了验证操作。 if(a>=0&&a<=150){ age = a ; } // 加入验证 上面说的是对属性的封装，接下来看方法，也就是构造方法。 构造方法：

只有对一个对象实例化，就是说出了new，就会调用构造方法，Person per = new Person() ;中new后面的person（）方法就是一个构造方法。 构造方法是干什么用的哪？

构造方法的主要目的就是为类中的属性进行初始化。 构造方法是怎么定义的哪？ Class 类名称{ 访问权限 类名称（参数类型1 参数1，参数类型2 参数2，。。。）{ 程序语句（注意构造方法没有返回值） } } 注意，构造方法名称必须与类名称保持一致；声明构造方法不能加返回值类型；构造方法不能使用return返回值。 例如： class Person{ } public Person(){ // 声明构造方法 System.out.println(\看到这句话，说明一个新的Person对象诞生了！！！\} 这就是一个构造方法。在声明对象的时候，是不会调用它的，只是在实例化对象的时候，才会启用构造方法。例如：

实例27：Constructdemo.java 目标：构造方法。

文件名：Constructdemo.java 文件路径：E:\\java\\7

学习内容：构造方法在实例化对象时才启用 代码内容： class Person{ public Person(){ // 声明构造方法 System.out.println(\看到这句话，说明一个新的Person对象诞生了！！！\ } } public class Constructdemo{ public static void main(String args[]){ System.out.println(\这里只声明对象：Person per = null ;\

} } Person per = null ; // 声明对象时不会去调用构造方法 System.out.println(\这里实例化对象：per = new Person() ;\per = new Person() ;//实例化对象，这时就启用了构造方法 运行时，先注解实例化对象，输出结果为： E:\\java\\7>java Constructdemo 这里只声明对象：Person per = null ; 然后取消注解，重新编译运行，输出结果为： E:\\java\\7>java Constructdemo 这里只声明对象：Person per = null ; 这里实例化对象：per = new Person() ; 看到这句话，说明一个新的Person对象诞生了！！！ 那么，我们在之前的例子中并没有去写构造方法，为什么还能正常执行呢，其实，这就是java的机制，如果我们没有编写构造方法，java会自行加载一个什么都不做的无参的构造方法： class Person{ } public Person(){ // 如果什么都不写，自动生成这个无参的什么都不做的构造方法 } 构造方法也是方法，那就可以往里面传递参数，比如我们把这个类的封装写全： class Person{ //定义一个类 private String name ; //定义类中的name属性，并封装 private int age ; //定义类中的age属性，并封装 public Person(String n,int a){ //声明构造方法，为类中的属性初始化 this.setName(n) ; //把值赋给name this.setAge(a) ; //把值赋给age } public void setName(String n){ //用seter方法设置name name = n ; } public void setAge(int a){ //用seter方法设置age if(a>0&&a<150){ //加上一个范围，看起来像个真事 age = a ; } } public String getName(){ //用geter方法获得name return name ; } public int getAge(){ //用geter方法获得age return age ; } public void eat(){ // 定义吃方法 System.out.println(\姓名：\，年龄：\，调用了吃方法。\ } public void drink(){ // 定义喝方法 System.out.println(\姓名：\，年龄：\，调用了喝方法。\} } 这段代码就完完整整的表达了一个类。代码中的this关键字表示对象本身，this.setName(n)的作用就是name=n。用this就是把name值传过来的时候也经过检验。直接等就是裸奔着过来，虽然可行，但是不好。

代码中已经明确的使用了一个构造方法，这时候就不会自动生成无参的啥也不干的构造方法了，所以这个时候再去运行，就会提示一个错误： E:\\java\\7>javac Constructdemo2.java Constructdemo2.java:35: 找不到符号 符号： 构造函数 Person() 位置： 类 Person per = new Person() ;//实例化对象，这时就启用了构造方法 ^ 1 错误 这个错误就是说没有可以调用的构造方法，因为new后面是person（），是个无参的方法，而类中的构造方法是public Person(String n,int a)，带着两个参数过来的，所以实例化per时，应该写成：

per = new Person(\淘淘\找个汉子或妹子，把程序补齐。

构造方法作为方法，也可以使用重载的。比如把参数的个数改变一下。找人试一下，奖励自告奋勇的，惩处畏缩不前的。

如果一个对象只用到一次，那可以采用匿名对象的方式，匿名，就是没有名字，上面定义了一个per对象，per就是对象名，只用一次的话，可以直接写成这样的方式： new Person(\淘淘\这就是匿名对象，没有名字，记住，只用一次的情况才能这样写，否则，会找不到对象的。

9.3 分析实例

学习到现在，可以对实际问题进行简单的分析了，在拿到一个具体问题的时候，按照以下的思路走，把问题分析清楚，再着手进行代码的编写，清晰明了。 1， 根据问题列出所需要的类； 2， 写出类中所有的属性； 3， 对列出的属性依次封装；（private）

4， 对封装的属性使用seter和geter方法存读； 5， 根据需要添加若干构造方法； 6， 为主方法添加相应的方法；

7， 类中的方法都不要输出，而是交给被调用处进行输出。 现在分析一个问题，比如我们面前的教材，把我们的教材名称和价格还有出版社等信息输出。 在这个问题中，第一步明显有一个类，就是教材，那定义个书类。

class Book{} 第二步，分析属性，有书名，有价格，有出版社，有作者，有isbn号，有了这几个属性，就基本确定了这本教材。列出来就是：

String Name 书名 备注 Float Price 价格 备注 出版社 作者 Isbn String String String Press Author Isbn 备注 备注 备注 第三步，根据这5个属性分别封装， Private String name; Private float price; Private String press; Private String author; Private String isbn; 第四步，为这5个属性分别列出存取的seter和geter方法，共10个： Public void setName(String n){ Name=n; } Public String getName(){ Return name; } Public void setPrice(float pe){ price=pe; } Public float getPrice(){ Return price; } Public void setPress(String ps){ press=ps; } Public String getPress(){ Return press; } Public void setAuthor(String a){ author=a; } Public String getAuthor(){ Return author; } Public void setIsbn(String i){ Isbn=i; } Public String getIsbn(){ Return isbn; } 第五步，添加构造方法，这里有5个属性，就传5个参数好了： Public Book(String n,float pe,String ps,String a,String i){ This.setName(n); This.setPrice(pe); This.setPress(ps); This.setAuthor(a); This.setIsbn(i); } 第六步，添加方法，比如说打印出这个教材： Public void print(){ System.out.println(“教材名称：”+this.getName()+”教材价格：”+this.getPrice()+教材出版社：”+this.getPress()+”教材作者：”+this.getAuthor()+”教材isbn号码：”+this.getIsbn()); } 现在完成这个实例：

实例28：Bookdemo.java 目标：类的分析。

文件名：Bookdemo.java 文件路径：E:\\java\\7

学习内容：分析问题的思路 代码内容： class Book{ private String name; private float price; private String press; private String author; private String isbn; public void setName(String n){ name=n; } public String getName(){ return name; } public void setPrice(float pe){ price=pe; } public float getPrice(){ return price; } public void setPress(String ps){ press=ps; } public String getPress(){ return press; } public void setAuthor(String a){ author=a; } public String getAuthor(){ return author; } public void setIsbn(String i){ isbn=i; } public String getIsbn(){ return isbn; } public Book(){} public Book(String n,float pe,String ps,String a,String i){ this.setName(n); this.setPrice(pe); this.setPress(ps); this.setAuthor(a); this.setIsbn(i); } public void print(){ System.out.println(\教材名称：\+ this.getName() + \，教材价格：\+ this.getPrice() + \出版社：\，作者：\，isbn：\this.getIsbn()) ; } } public class Bookdemo{ public static void main(String args[]){ Book book=null; book=new Book(\面向对象程序设计\清华大学出版社\耿详义、张跃平\ book.print(); } } 运行结果为： E:\\java\\7>java Bookdemo 教材名称：java面向对象程序设计，教材价格：34.0出版社：清华大学出版社，作者：耿详义、张跃平，isbn：9787-302-21352-9 这就是类的分析过程。其中有个句子Book book=null，这样的句子初学时很容易犯迷糊，尤其是声明与赋值写在一起，三个单词一样的，只是首字母大小写的问题。心里一定要清楚的知道，大写的是类，小写的是对象。回想一下，写别的数据类型都是小写，如int，float

本文来源：https://www.bwwdw.com/article/vlt7.html