输入三个整数x,y,z，请把这三个数由小到大输出。
 
import java.util.*;
 
public class lianxi15 {
 
public static void main(String[] args) {
 
input fnc = new input();
 
int x=0, y=0, z=0;
 
System.out.print("输入第一个数字：");
 
x = fnc.input();
 
System.out.print("输入第二个数字：");
 
y = fnc.input();
 
System.out.print("输入第三个数字：");
 
z = fnc.input();
 
if(x > y) {
 
int t = x;
 
x = y;
 
y = t;
 
}
 
if(x > z) {
 
int t = x;
 
x = z;
 
z = t;
 
}
 
if(y > z) {
 
int t = y;
 
y = z;
 
z = t;
 
}
 
System.out.println( "三个数字由小到大排列为： "+x + " " + y + " " + z);
 
}
 
}
 
class input{
 
public int input() {
 
int value = 0;
 
Scanner s = new Scanner(System.in);
 
value = s.nextInt();
 
return value;
 
}
 
}

 
1、cmd的使用方法：
 

 
2、环境变量的配置：
 

 

 
第一章 Java基础
 
一、Java语言开发环境开发及搭建
 
1、JRE：是Java程序的运行环境，包含JVM和运行时所需的核心类库
 
2、JDK：是Java程序开发工具包，包含JRE和开发人员使用的工具
 

 
二、Java注释
 
1、单行注释和多行注释
 

 
2、Java语言中每一行代表的意思：
 

 
三、关键字
 
1、关键字的特点：
 
1)完全小写的字母；
 
2)在增强版的记事本当中有特殊颜色。
 
四、标识符
 
1、定义
 
是指在程序中，我们自己定义的内容。比如类的名称、方法的名字和变量的名字等等，都是标识符。
 
2、命名规则
 
1)标识符可以包含英文字母(区分大小写)、数字、＄(美元符号)、_(下划线)
 
2)标识符不能以数字开头
 
3)标识符不能是关键字
 
3、命名规范
 
1)类名规范：首字母大写，后面每个单词首字母大写(大驼峰式)。
 
2)变量名规范：首字母小写，后面每个单词首字母大写(小驼峰式)。例如：helloWorld
 
3)方法名规则：同变量名。
 
五、常量
 
1、定义：
 
在程序运行期间，固定不变的量。
 
2、常量的分类：
 
1)字符串常量：凡是用双引号 引起来的部分，叫做字符串常量。
 
2)整数常量：直接写上的数字，没有小数点。
 
3)浮点数常量：直接写上的数字，有小数点。
 
4)字符常量：凡是用单引号引起来的单个字符，叫做字符常量。
 
5)布尔常量：只有两中取值。true、false
 
6)空常量：null。代表没有任何数字。
 

 
六、基本数据类型
 
1、整形
 
1)byte
 
2)short
 
3)int
 
4)long
 
2、字符型
 
char
 
3、浮点型
 
1)float
 
2)double
 
4、布尔型
 
boolean
 

 
注：Java默认类型为：整数类型int和浮点数类型double
 

 
七、数据类型的转换
 

 

 
八、强制数据类型转换
 

 
数据溢出：
 

 

 
精度损失：
 

 

 

 
九、ASCII码
 

 
十、运算符
 
1、四则运算符
 

 

 
2、四则运算中 ’+‘的用法有三种：
 

 

 
3、自增自减运算符
 
单独使用：
 

 
混合使用：
 

 

 

 
注：只有变量才可以有自增、自减操作，常量不可能发生改变，所以不可用。
 
4、赋值运算符
 

 
注：1)只有变量才能使用赋值运算符，常量不能进行2赋值；
 
2)复合运算符其中隐含一个强制类型转换；例如：
 

 
5、比较运算符
 

 
注：1)比较运算符的结果一定是一个boolean类型，成立为true，不成立为false；
 
2) 比较运算符如果进行多次比较，不能连着写。
 

 
6、逻辑运算符·
 
逻辑运算符：
 
逻辑与　　&　　两个操作数均为true时，结果才为true
 
逻辑或　　|　　   两个操作数均为false时，结果为false
 
逻辑非　　！　　将操作数取反
 
简洁与　　&&　　两个操作数均为true时，结果才为true
 
简洁或　　||          两个操作数均为false时，结果为false
 
异或　　    ^　　   两个操作数同为真或同为假时，结果才为true
 

 

 
注：
 
7、三元运算符
 

 
格式：
 

 
注：
 

 
8、优先级
 
从高到低依次为：一元运算符、算术运算符、关系运算符和逻辑运算符、赋值运算符
 
第二章  方法入门
 
一、定义一个方法的格式：
 
1、格式：
 
public static void 方法名称() {  }
 

 
方法名称的命名规则和变量一样，使用小驼峰式。
 
方法体：也就是大括号当中可以包含任意条语句。
 
2、注意事项
 
1)方法定义的先后顺序无所谓
 
2)方法的定义不能产生嵌套包含关系
 
3)方法调用好了之后，不会执行的。如果要想执行，一定要进行方法的【调用】。
 
3、如何调用方法，格式：
 
方法名称();
 

 
例如：
 

 
二、编译器的两点优化：
 
注意事项1：
 

 
注意事项2：
 

 
注：布尔类型不能进行数据转换
 
第一章   Java语言概述
 
一、Java的特点：
 
1、简单易学：Java去掉了C/C++所使用的数据类型：指针(pointer)、联合体(unions)和结构体(structs)
 
2、面向对象：面向对象的语言都支持封装、继承和多态三个概念
 
3、平台无关性：
 
平台无关性有两种：源代码级和目标代码级。Java语言是靠Java虚拟机(JVM)在目标代码级实现平台无关性的。
 
4、分布式：
 
分布式包括数据分布和操作分布。Java语言支持这两种分布性。
 
5、可靠性：
 
6、安全性：
 
7、支持多线程：
 
Java在两方面支持多线程：一方面，Java环境本身就是多线程的，若干系统线程运行，负责必要的无用单元回收、系统维护等系统级操作；另一方面，Java语言内置多线程机制，可以大大简化多线程应用程序开发。
 
8、支持网络编程：
 
Java语言通过它所提供的类库可以处理tcp/ip，用户可以通过URL地址在网络上很方便地访问其他对象。
 
9、编程与解释并存：
 
Java语言的编译器并不是把源文件(.Java)编译成二进制码，而是将其编译成一种独立于机器平台的字节码文件(.class文件)。字节码文件可以被Java解释器执行，有解释器将字节码文件再翻译成二进制码，是程序得以运行。
 
二、Java语言规范
 
Java语言为开发Java程序而定义了类和接口，称为应用程序接口(API)。
 
Java技术包括三个方面：https://wenda.so.com/q/1507788655213951
 
1)Java SE(Java Platform Standard Edition)：Java平台的标准版，可以用于开发客户端应用程序。应用程序可以独立运行或作为Applet在Web上运行。
 
2)Java ME (Java Platform Micro Edition)：Java平台的精简版，用于开发移动设备的应用程序。不论是无线通信还是手机、PDA等小型电子装置，均可采用Java ME作为开发工具及应用平台。’；l
 
3)Java EE(Java Platform EnterPrise Edition)：Java平台的企业版本，用于开发服务器端的应用程序，为企业提供了e-Business架构及其Web服务。其优越的跨平台能力与开放的标准。深受广大企业用户的喜爱。
 
三、Java虚拟机
 
1、Java虚拟机的定义：
 
Java虚拟机(Java Virtual Machine 简称JVM)是运行所有Java程序的抽象计算机，是Java语言的运行环境，它是Java 最具吸引力的特性之一。JVM其实就是一个字节码解释器。
 
2、Java程序的执行过程：先编译，后解释
 

 
字节码是Java虚拟机的指令组，和CPU上的微指令码很像，。Java程序编译成字节码文件尺寸较小，便于网络传输。
 
字节码最大的好处是可跨平台运行，即Java的字节码可以编写一次，到处运行。
 
四、Java程序的种类和结构
 
使用Java语言可以编写两种类型的程序：Application(应用程序)和Applet(小程序)。开发原理相同，但运行环境和计算结构不同。
 
一个复杂的程序可以由一个或多个Java源文件构成，每个文件中可以有多个类定义。
 
一般的Java源程序文件由三部分组成：1) package语句(0个或1个)；
 
2)import语句(0个或多个)；
 
3)类定义(1个或多个类定义)。
 
注： 1)package语句表示该程序所属的包。他只能有一个或没有。如果有，必须放在最前面；如果没有，表示本程序属于默认值。
 
2)import语句表示引入其他类库中的类，以便使用。import语句可以有0个或多个，它必须放在类定义的墙面。
 
3)类定义是Java源程序的主要部分，每个文件中可以定义若干类。
 
Java程序中定义类使用关键字class，每个类的定义由类头定义和类体定义两部分组成。
 
注：Java是严格区分字母大小写的语言。书写时，大小写不能混析
 
字节码最大的好处是可跨平台执行，，可让程序“编一次，到处运行”的梦想成真。
 
第四章         Java运行流程
 
一、流程控制
 
1.1  顺序结构
 
流程图：
 

 
1.2  判断语句
 
《一》判断语句1----if
 
1、格式：
 

 
2、流程：
 

 
《二》判断语句2----if......else
 
1、格式：
 

 
2、流程图
 

 
例如：
 

 
《三》判断语句3----if...else  if...else
 
1、格式
 

 
注：
 
2、流程图：
 

 
1.3  选择结构
 
《一》选择语句1--switch
 
1、格式：
 

 
2、执行流程：
 
1)首先计算出表达式的值；
 
2)其次，和case一次比较，一旦有对应的语句，在执行的过程中，遇到break就会结束。
 
3)最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
 

 
3、例如：
 

 
4、switch语句使用的注意事项：
 
1)多个case后面的数值不可以重复。
 
2)switch后面的小括号当中只能是下列数据类型：
 
基本数据类型：byte/short/char/int
 
引用数据类型：String字符串、enum枚举
 
3)switch语句格式可以灵活：前后顺序可以颠倒，而且break语句还可以省略。
 
“匹配哪一个case就从哪一个位置向下执行，直到遇到了break或者整体结束为止。”
 
1.4  循环语句
 
循环结构的基本组成部分，一般可以分成四部分：
 
1)初始化语句：再循环开始最初执行，而且只做唯一一次。
 
2)条件判断：如果成立，则循环继续；如果不成立，则循环退出。
 
3)循环体：重复要做的事情内容，若干行语句。
 
4)步进语句：每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次。
 
《一》循环语句1--for
 
1、格式：
 

 
①初始化表达式：
 
②布尔表达式：
 
③循环体：
 
④步进表达式：
 
2、流程图
 

 
《二》循环语句2--while
 
while循环有一个标准格式，还有一个扩展格式。
 
1、标准格式：
 
while (条件判断){循环体}
 
流程图：
 

 
2、扩展格式：
 

 
3、for循环和while的区别：可以相互转化
 

 
《三》循环语句3--   do-while
 
1、标准格式：
 

 
2、扩展结构
 

 
3、流程图
 

 
1.5   三种循环的区别：
 
1)如果条件判断从来没有满足过，那么for循环和while循环将执行0次，do-while将会执行一次。
 
2)for循环的变量在小括号内当中定义，只有循环内部才可以使用，while和do-while循环初始化语句本来就在外边，所以出来循环之后还可以继续使用。
 
1.6   条件控制语句：
 
1、break关键字的用法有常见的两种：
 
1)可以用在switch语句当中，一旦执行，整个switch语句立刻结束。
 
2)还可以用在循环语句当中，一旦执行，整个循环语句立刻结束。打断循环。
 
2、另一种循环控制语句是continue关键字。
 
一旦执行，立刻跳过当前次·循环剩余内容，马上可以下一次循环
 
1.7  死循环
 
永远停不下来的循环，叫做死循环。
 
死循环的标准格式：
 
while(true){  循环体}
 
二、快捷键
 

 
第五章 方法
 
一、方法的定义：
 
方法其实就是若干语句的功能集合。
 
二、定义方法的完整格式：
 
修饰符  返回值类型   方法名称(参数类型   参数名称，...)
 
{
 
方法体；
 
return  返回值；
 
}
 
其中：
 
修饰符：现阶段的固定写法，public static
 
返回值类型：也就是方法最终产生的数据结果是什么类型
 
方法名称：方法的名字，规则和变量一样，小驼峰式。
 
参数类型：进入方法的数据是什么类型
 
参数名称：进入方法的数据对应的数据名称
 
备注：参数如果有多个，使用逗号进行分隔
 
方法体：方法需要做的事情，若干行代码
 
return：两个作用，第一停止当前方法，第二将后面的返回值还给调用处
 
返回值：也就是方法执行后最终产生的数据结果
 
注意：return后面的“返回值”，必须和方法名称后面的“返回值类型”保持对应
 
例如：
 
定义一个两个int数字相加的方法，三要素：
 
1)返回值类型：int
 
2)方法名称：sum
 
3)参数列表：int   a，int 　b
 
三、方法的三种调用格式：
 
1、单独调用：方法名称(参数)；
 
2、打印调用：System.out.println(方法名称(参数))；
 
3、赋值调用:数据类型　变量名称  =  方法名称(参数)；
 
注意：返回值类型固定写为void，这种方法只能够单独调用，不能进行打印调用或者赋值调用。
 

 

 
赋值调用的方法：
 

 
四、方法参数
 
·1、方法有参数：小括号当中有内容，当一个方法需要一些数据条件，才能完成任务的时候，就是有参数。
 
例如：两个数字相加，必须知道两个数字各是多少，才能相加。
 

 
2、方法有参数：小括号当中留空。一个方法不需要任何数据条件，自己就能独立完成任务，就是无参数。
 
例如：定义一个方法，打印固定10次HelloWorld。
 

 

 
注意事项：
 
对于有返回值的方法，可以使用单独调用、打印调用或者赋值调用
 
但是对于无法使你会值得方法，只能使用单独调用，不能使用打印调用或者赋值调用。
 

 
练习题
 
1、判断两个数据是否相同
 

 
五、方法的注意事项
 
1、方法应该定义在类当中，但是不能再方法当中再定义方法。不能嵌套。
 
2、方法定义的先后顺序无所谓。
 
3、方法定义之后不会执行，如果希望执行，一定要调用：单独调用、打印调用、赋值调用。
 
4、如果方法有返回值，那么必须写上“return  返回值；”不能没有。
 
5、return后面的返回值数据，必须和方法的返回值类型对应起来。
 

 
6、对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己。
 

 
7、duiyuvoid方法当中最后一行的return可以省略不写。
 

 
8、一个方法当中可以有多个return语句，但是必须保证同时只有一个会被执行，两个return不能连写。
 

 
六、方法重载的基本使用
 
对于功能类似的方法来说，因为参数列表不一样，却需要记住那么多不同的方法名称，太麻烦。
 
方法重载(overload)，多个方法的名称一样，但是参数列表不一样。
 
好处：只需要记住唯一一个方法名称，就可以实现类似的多个功能。
 

 
2、方法重载与下列因素相关：
 
1)参数个数不同
 
2)参数类型不同
 

 
3)参数的多类型顺序不同
 

 
3、方法重载与下列因素无关
 
1)与参数的名称无关
 

 
2)与方法的返回值类型无关
 

 
第六章  数组
 
一、数组的定义：
 
数组是一种容器，可以同时存放多个数据值。
 
二、数组的特点：
 
1、数组是一种引用数据类型
 
2、数组当中的多个数据，类型必须统一
 
3、数组的长度在成序运行期间不可改变
 
三、数组的使用
 
1、创建数组的动作叫数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值。
 
2、常见的两种初始化方式：
 
1)动态初始化(指定长度)：在创建数组时，直接指定数组当中的数组元素个数。
 
2)静态初始化(指定内容)：在创建数组时，不直接指定数据个数多少，而是直接将具体的数据内容进行指定。
 
3、动态初始化
 
1)动态初始化数组的格式：
 
数据类型[ ]  数组名称   =   new 数据类型[数组长度]；
 
2)含义解析：
 
左侧的数据类型：也就是数组当中保存的数据，全都是统一的什么类型
 
左侧的中括号：代表一个数组
 
左侧的数组名称：给数组取一个名字
 
右侧的new：代表创建数组的动作
 
右侧的数据类型：必须和左侧的数据类型保持一致
 
右侧中括号当中的长度：也就是数组当中到底可以保存多少数据，是一个int数字
 
4、静态初始化德
 
1)基本格式：
 
数据类型[ ]  数组名称  =  new  数据类型[  ]  {元素1，元素2，. . .};
 
2)注意事项：虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出长度。
 
3)省略格式
 
数据类型[ ]  数组名称  =   {元素1，元素2，. . .};
 
4)注意事项
 
①静态初始化煤油直接指定长度，但仍然会自动推算得到长度
 
②静态初始化标准格式可以拆分称为两个步骤
 
③动态初始化也可以拆分成为两个步骤
 
④静态初始化一旦使用省略格式就不能拆分成两个步骤了
 

 
5)使用建议
 
如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化。
 
四、数组元素的获取
 
1、直接打印的数组名称，得到的是数组对应的：内存地址哈希值
 

 
2、访问数组元素的格式：数组名称[索引值]
 
索引值：就是一个int数字，代表数组当中元素的编码
 
【注意】索引值从0开始，一直到”数组的长度-1“为止
 

 
3、使用动态初始化数组时，其中的元素将会自动拥有一个默认值。规则如下：
 
如果是整数类型，那么默认值为0；
 
如果时浮点类型，那么默认值为0.0；
 
如果是字符类型，那么默认值为‘\u0000’;
 
如果是布尔类型，那么默认值为false；
 
如果是英语类型，那么默认类型为null。
 
4、注意事项
 
静态初始化其实也有默认值得过程，只不过系统自动马上将默认值替换成为了大括号当中的具体数据。
 
五、Java中内存的划分(5个部分)：
 
1、栈(Stack)：存放的都是方法中的局部变量。方法的运行一定在站当中运行。
 
局部变量：方法的参数，或者是方法{ }内部的变量
 
作用域：一旦超出作用域，立刻从栈内存当中消失。
 
2、堆(Heap)：凡是new出来的东西，都在对当中。
 
堆内存里的东西都有一个地址值：16进制
 
堆内存里面的数据，都有默认值。
 
如果是整数类型，那么默认值为0；
 
如果时浮点类型，那么默认值为0.0；
 
如果是字符类型，那么默认值为‘\u0000’;
 
如果是布尔类型，那么默认值为false；
 
如果是英语类型，那么默认类型为null。
 
3、方法区(Method Area)：存放.class相关信息，包含方法的信息。
 
4、本地方法栈(Native Method Stack)：与操作系统相关。
 
5、寄存器(pc Register)：与CPU相关。
 
六、一个数组的内存圈
 

 
0x是16进制的前缀。
 
七、两个数组的内存圈
 
要运行必须将方法区当中的内容加载到内存当中，并为他开辟一块内存空间。
 

 
八、两个应用指向同一个数组的内存圈
 

 
九、常见问题
 
数组的索引编号从0开始，一直到“数组长度-1”为止。
 
1、数组索引越界异常
 

 
如果访问数组元素的时候，索引编号并不存在，那么将会发生：数组索引越界异常(ArrayIndexOutOfBoundsException)
 
原因：缩引编号在写错了
 
解决办法：修改成为存在的真确索引编号。
 
2、空指针异常
 

 
所有的引用类型变量，都可以赋值为一个null值。但是代表其中什么都没有。
 
数组必须进行new初始化才能使用其中的元素。
 
如果只是赋值了一个null，没有进行new创建，那么将会发生：
 
空指针异常：NullPointerException
 
原因：忘了new
 
解决办法：补上new
 
十、获取数组的方法
 
获取数组长度的方法：数组名称.length
 
将会得到一个int数字，代表数组的长度，
 
数组一旦创建，程序运行期间，长度不可改变。
 

 

 
十一、数组的遍历
 
遍历数组：说的是对数组当中的每一个元素进行逐一、挨个儿处理。默认的处理方式是打印输出
 
十二、数组元素的反转
 
1、数组元素反转，其实就是对称位置的元素交换。
 
2、通常遍历数组用的是一个索引：
 
int　i=0；
 
现在表示对称位置需要两个索引：
 
int   min=0；
 
int   max=array.length-1；
 
3、如何交换两个变量值？
 
int  a=10；
 
int  b=20；
 
如果是两个水杯，都是满的，如何交换？借助第三个杯子。
 
int  temp=a；
 
a=b；
 
b=temp；
 
用三个变量倒手。
 

 
4、什么时候停止
 
1)min==max；
 
2)min>max;这两个可以推出min
 
题目：将数组中的元素依次互换位置，使其变为{50，40，300，20，10}。
 

 

 
十三、基本数据类型和引用数据类型的区别：
 
1、所有的变量都存储在栈内存
 
2、变量空间可以存储基本数据类型，也可以存储引用数据类型
 
3、如果变量空间存储的是基本数据类型，则存储的是值，一个变量的值改变，另一个不会跟着改变
 
4、如果变量空间存储的是引用数据类型，则存储的是引用(地址)，一个变量地址对应的值改变，另一个也跟着改变。
 
十四、习题
 
1、给定两个数组a{1，2，3，4}，b{5，6，7，8，)，将两个数组内的元素对应位置互换。
 

 
加入两个数组的长度互不相同时，可以直接交换变量a和b中数组引用(地址)，没有循环，一次就搞定了，不受长度的限制。
 

 
当两个数组的长度相同时，可直接用for循环交换数组中对应的元素(循环好多次，受长度的限制)。
 

 
·2、给定两个数组a{1，2，3}，b{4，5}合并两个数组(方法：创建一个新的数组)
 
思路一：分别将a和b数组中的元素存入新数组内。
 

 
思路二：想要将新数组填满。
 

 
3、给定一个数组a{1，2，3，0，0，4，5，0，6，0，7}去掉数组中的0元素(创建一个新数组，短的，非零元素挑出来。
 

 

 

 
4、创建一个数组，存储2到100之间的素数(质数)
 
思路一：空间占用小，执行效率慢
 
0、通过一个几千次的循环寻找一个---count
 
1、创建一个数组，长度(刚好，没有一个空间多余)
 
2、通过一个几千次的循环找寻素质，将素数存入数组内
 

 

 
思路二：执行效率高，空间占用大
 
0、创建一个足够长的数组
 
1、通过几千次的循环找素数，将素数存入数组内
 
2、将存入素数的数组，后面部分0元素去掉
 

 

 
5、数组元素的排序(冒泡 选择)
 
数组元素的排序本质是交换位置(交换位置的条件)
 
1》冒泡排序法(升序----数组底端冒出一个泡【最小值】)
 

 
执行结果：
 

 

 
6、用户登录认证(用数组当作小数据库  存值  用户验证)
 
用户登录认证的步骤：
 

 
十五、二维数组
 
1、　二维数组的静态初始化：
 
方法一：
 

 
方法二：
 

 
增强for循环：
 

 
执行结果：
 

 
2、二维数组的动态初始化：

 
商品描述：
 
基本信息
 
书名:Java程序设计精编教程-(第3版)-微课版
 
定价：39.5元
 
作者:耿祥义、张跃平
 
出版社：清华大学出版社
 
出版日期：2017-09-01
 
ISBN：9787302473169
 
字数：516000
 
页码：323
 
版次：3
 
装帧：平装-胶订
 
开本：16开
 
商品重量：
 
编辑推荐
 
基础与实战。相关概念及知识点都辅以相应的实例，通俗易懂，便于理解掌握面向对象的编程思想。实用与流行。涵盖了Java开发过程中重要的及流行的方法和技巧，讲解细致，环环相扣。教学与互动。文字叙述注重可读性，知识组织注意合理性，提供辅助在线教学平台。
 
内容提要
 
Java语言具有面向对象、与平台无关、安全、稳定和多线程等优良特性，是目前软件设计中极为强大的编程语言，特别适合于网络应用程序的设计，已经成为网络时代*重要的语言之一。本书精选Java核心内容，注重结合实例，循序渐进地向读者介绍Java语言的核心内容，在基础语言上强调Java面向对象编程的思想，在实用类上侧重应用。全书分为14章，分别讲解简单数据类型、运算符、表达式和语句、类与对象、子类与继承、接口与实现、内部类与异常类、常用实用类、Java输入输出流、组件与事件处理、Java多线程机制、Java网络编程、JDBC数据库操作等内容。本书使用的JDK版本是JDK 1.8(即JDK 8)，并提供了70小时微课教学视频，扫描每章提供的可观看视频讲解。本书适合高等院校计算机专业作为Java语言程序设计的教材以及想掌握Java核心内容的自学者。
 
目录
 
目录第1章Java入门1.1Java的平台无关性1.1.1平台与机器指令1.1.2C/C  程序依赖平台1.1.3虚拟机与平台1.2Java之父——James Gosling1.3Java的地位1.3.1网络地位1.3.2语言地位1.3.3需求地位1.4安装JDK1.4.1平台简介1.4.2安装Java SE平台1.5Java程序的开发步骤1.6一个简单的Java应用程序1.6.1编写源文件1.6.2编译1.6.3运行1.7上机实践习题第2章Java应用程序的基本结构2.1问题的提出2.2简单的Circle类2.3使用Circle类创建对象2.3.1用类声明对象2.3.2为对象分配变量2.3.3使用对象2.4在应用程序中使用对象2.5Java应用程序的基本结构2.6在一个源文件中编写多个类2.7编程风格2.7.1Allmans风格2.7.2Kernighan风格2.7.3注释2.8上机实践习题第3章标识符与简单数据类型3.1标识符与关键字3.1.1标识符3.1.2关键字3.2简单数据类型3.2.1逻辑类型3.2.2整数类型3.2.3字符类型3.2.4浮点类型3.3简单数据类型的级别与类型转换运算3.4从命令行窗口输入、输出数据3.4.1输入基本型数据3.4.2输出基本型数据3.5上机实践习题第4章运算符、表达式与语句4.1运算符与表达式4.1.1算术运算符与算术表达式4.1.2自增，自减运算符4.1.3算术混合运算的精度4.1.4关系运算符与关系表达式4.1.5逻辑运算符与逻辑表达式4.1.6赋值运算符与赋值表达式4.1.7位运算符4.1.8instanceof运算符4.1.9运算符综述4.2语句概述4.3if条件分支语句4.3.1if语句4.3.2ifelse语句4.3.3ifelse ifelse语句4.4switch开关语句4.5循环语句4.5.1for循环语句4.5.2while循环4.5.3dowhile循环4.6break和continue语句4.7数组4.7.1声明数组4.7.2为数组分配元素4.7.3数组元素的使用4.7.4length的使用4.7.5数组的初始化4.7.6数组的引用4.7.7遍历数组4.8上机实践习题第5章类与对象5.1面向对象的特性5.2类5.2.1类声明5.2.2类体5.2.3成员变量5.2.4方法5.2.5需要注意的问题5.2.6类的UML类图5.3构造方法与对象的创建5.3.1构造方法5.3.2创建对象5.3.3使用对象5.3.4对象的引用和实体5.4参数传值5.4.1传值机制5.4.2基本数据类型参数的传值5.4.3引用类型参数的传值5.5对象的组合5.5.1由矩形和圆组合而成的图形5.5.2关联关系和依赖关系的UML图5.6实例成员与类成员5.6.1实例变量和类变量的声明5.6.2实例变量和类变量的区别5.6.3实例方法和类方法的定义5.6.4实例方法和类方法的区别5.7方法重载与多态5.8this关键字5.8.1在构造方法中使用this5.8.2在实例方法中使用this5.9包5.9.1包语句5.9.2有包名的类的存储目录5.9.3运行有包名的主类5.10import语句5.10.1引入类库中的类5.10.2引入自定义包中的类5.11访问权限5.11.1何谓访问权限5.11.2私有变量和私有方法5.11.3共有变量和共有方法5.11.4友好变量和友好方法5.11.5受保护的成员变量和方法5.11.6public类与友好类5.12基本类型的类包装5.12.1Double和Float类5.12.2Byte、Short 、Integer、Long类5.12.3Character类5.13可变参数5.14上机实践习题第6章子类与继承6.1子类与父类6.2子类的继承性6.2.1子类和父类在同一包中的继承性6.2.2子类和父类不在同一包中的继承性6.2.3继承关系(Generalization)的UML图6.3成员变量的隐藏和方法重写6.3.1成员变量的隐藏6.3.2方法重写(Override)6.4super关键字6.4.1用super操作被隐藏的成员变量和方法6.4.2使用super调用父类的构造方法6.5final关键字6.5.1final类6.5.2final方法6.5.3常量6.6对象的上转型对象6.7继承与多态6.8abstract类和abstract方法6.9面向抽象编程6.10开闭原则6.11上机实践习题第7章接口与实现7.1接口7.2实现接口7.3理解接口7.4接口的UML图7.5接口回调7.6接口与多态7.7接口变量做参数7.8abstract类与接口的比较7.9面向接口编程7.10上机实践习题第8章内部类与异常类8.1内部类8.2匿名类8.2.1和子类有关的匿名类8.2.2和接口有关的匿名类8.3异常类8.3.1trycatch语句8.3.2自定义异常类8.3.3finally子语句8.4断言8.5上机实践习题第9章常用实用类9.1String类9.1.1构造字符串对象9.1.2String类的常用方法9.1.3字符串与基本数据的相互转化9.1.4对象的字符串表示9.1.5字符串与字符、字节数组9.1.6正则表达式及字符串的替换与分解9.2StringBuffer类9.2.1StringBuffer对象的创建9.2.2StringBuffer类的常用方法9.3StringTokenizer类9.4Date类9.4.1构造Date对象9.4.2日期格式化9.5Calendar类9.6Math和BigInteger类9.6.1Math类9.6.2BigInteger类9.7DecimalFormat类9.7.1格式化数字9.7.2将格式化字符串转化为数字9.8Pattern与Match类9.8.1模式对象9.8.2匹配对象9.9Scanner类9.10上机实践习题第10章输入输出流10.1File类10.1.1文件的属性10.1.2目录10.1.3文件的创建与删除10.1.4运行可执行文件10.2字节流与字符流10.2.1InputStream类与OutputStream类10.2.2Reader类与Writer类10.2.3关闭流10.3文件字节流10.3.1文件字节输入流10.3.2文件字节输出流10.4文件字符流10.5缓冲流10.6流10.7数组流10.8数据流10.9对象流10.10序列化与对象克隆10.11文件锁10.12使用Scanner解析文件10.13上机实践习题第11章组件及事件处理11.1Java Swing概述11.2窗口11.2.1JFrame常用方法11.2.2菜单条、菜单、菜单项11.3常用组件与布局11.3.1常用组件11.3.2常用容器11.3.3常用布局11.3.4选项卡窗格11.4处理事件11.4.1事件处理模式11.4.2ActionEvent事件11.4.3ItemEvent事件11.4.4DocumentEvent事件11.4.5MouseEvent事件11.4.6焦点事件11.4.7键盘事件11.4.8匿名类实例或窗口做监视器11.4.9事件总结11.5使用MVC结构11.6对话框11.6.1消息对话框11.6.2输入对话框11.6.3确认对话框11.6.4颜色对话框11.6.5文件对话框11.6.6自定义对话框11.7发布GUI程序11.8上机实践习题第12章Java多线程机制12.1进程与线程12.1.1操作系统与进程12.1.2进程与线程12.2Java中的线程12.2.1Java的多线程机制12.2.2线程的状态与生命周期12.2.3线程调度与优先级12.3Thread类与线程的创建12.3.1使用Thread的子类12.3.2使用Thread类12.3.3关于run方法启动的次数12.4线程的常用方法12.5线程同步12.6在同步方法中使用wait()、notify()和notifyAll()方法12.7线程联合12.8上机实践习题第13章Java网络编程13.1URL类13.1.1URL的构造方法13.1.2读取URL中的资源13.2InetAddress类13.2.1地址的表示13.2.2获取地址13.3套接字13.3.1套接字概述13.3.2客户端套接字13.3.3ServerSocket对象与服务器端套接字13.3.4使用多线程技术13.4UDP数据报13.4.1发送数据包13.4.2接收数据包13.5广播数据报13.6Java远程调用(RMI)13.6.1远程对象及其代理13.6.2RMI的设计细节13.7上机实践习题第14章JDBC数据库操作14.1Derby数据库14.2在命令行连接内置Derby数据库14.2.1启动ij环境14.2.2连接内置Derby数据库14.2.3操作表14.2.4Derby数据库常用的基本数据类型14.3在命令行连接网络Derby数据库14.3.1启动Derby数据库服务器14.3.2连接网络Derby数据库14.4JDBC14.4.1连接内置Derby数据库14.4.2连接网络Derby数据库14.5查询操作14.5.1顺序查询14.5.2控制游标14.5.3条件与排序查询14.6更新、添加与删除操作14.7使用预处理语句14.7.1预处理语句优点14.7.2使用通配符14.8事务14.8.1事务及处理14.8.2JDBC事务处理步骤14.9上机实践习题参考文献
 
作者介绍
 
序言

 
JAVA程序设计
 
第一章：从0开始学习java
第二章 java的基本语法详解
2.1标识符和关键字
2.1.1标识符
2.1.2关键字
   
2.2基本数据类型
2.2.1 整数类型
2.2.2 浮点类型
2.2.3 字符类型
2.2.4 布尔类型
   
2.3常量和变量
2.3.1 常量
2.3.2 变量
2.3.3 变量作用域
   
2.4 运算符
2.4.1赋值运算符
2.4.2 算数运算符
2.4.3 关系运算符
2.4.4 逻辑运算符
2.4.5 位运算符
2.4.6 条件运算符（?:）
2.4.7 运算符的优先性与结合性
   
2.5 数据类型转换
2.6 流程控制语句
2.6.1 分支语句
2.6.2 循环语句
2.6.3 跳转语句—break与continue语句
   
2.8数组
2.8.1 一维数组
2.8.2 多维数组
  
  
第三章 面向对象程序准备
3.1 面向对象程序设计的概述
面向对象的理解
   
3.2 类与对象
类的定义
成员变量
类的对象
成员变量和成员方法的使用
    
方法中的参数传递
   
3.3 类的构造方法
对象数组（类似学生类）
3.7重载
3.7.1 方法重载
3.7.2 构造方法的重载
   
3.8 static、final修饰符详解
static
  
 

 
第一章：从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种
 
类类型（Class Type)
 
 
 
package, class, abstract, interface, implements, native, this, super, extends, new, import, instanceof, public, private, protected
 
 
数据类型（Data Type)
 
 
 
char, double, enum, float, int, long, short, boolean, void, byte
 
 
控制类型（Control Type）
 
 
 
break, case, continue, default, do, else, for, goto, if, return, switch, while, throw, throws,try, catch, synchronized, final, finally, transient, strictfp
 
 
储存类型（Storage Type)
 
 
 
register , static
 
 
其他类型（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 <B）为真。
>=
检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。
（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<short<int<long<float<double
 
 
实例：代码如下：
 
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语句
 
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：初始化表达式，通常用于给循环变量赋初值。
表达式2：条件表达式，它是一个布尔表达式，只有值为true时候才会继续执行for语句中的语句块
表达式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。而这在非静态成员变量是不行的；
 
静态代码块