3--方法&数组&IDE
1、开发工具
1.1、开发工具介绍
作为一名开发人员，在实际的工作需要选择合适的开发工具可以快速提高开发效率。针对Java也有很多对应的开发工具。现在就介绍一款开发中使用最多的工具Eclipse。
1.2、eclipse下载
下载eclipse，需要到对应官方网站下载：http://www.eclipse.org/
点击download，会进入下载页面
继续点击download，下载eclipse-inst-win64.exe。
点击click here连接，进行下载。
下载之后，双击安装（其实这个文件就是一个）
选择 eclipse IDE for JavaEE Developers，以后开发使用这个。
更改安装的位置
选择现在接受，开始安装
开始安装，等待结束。
安装完成：
1.3、使用eclipse
双击桌面图标 ，启动eclipse软件
选择将来书写的代码（项目）保存的路径（建议不要有中文和空格的目录）。
启动后的eclipse（注意：这里用的不是最新版本eclipse，但使用没有太大差异）
1.3.1、切换视图
在eclipse的右上角，选择
选中java之后，点击open打开这个视图。
1.3.2、创建项目（工程）
在Package Explorer 视图（窗口）中，右击选择 new（创建）Java Project（Java项目或工程）。
书写项目名称之后，点击finish完成项目创建。
创建好的项目
1.3.3、书写代码
选中src 文件夹，然后右击 ，new 一个class，即就是创建一个用于写代码的java文件。
在创建class的过程中：Package可以先不填写。后面会介绍如何书写。Name必须填写，是当前创建的class的名字
书写代码：
1.3.4、运行代码
在写好的代码上右击 选择 Run as Java Application 即可运行（这里不需要再使用javac命令编译了）
控制台显示的结果。
1.3.5、修改eclipse的字体
选择window菜单下的preferences菜单.
在general 下面的 appearance 中的colors and fonts。
在basic 中选择最后一项，Text Font
点击右侧的Edit，修改字体等信息
修改后的效果
1.4、eclipse常用快捷键
alt + / 代码补全提示
ctrl + 1 错误提示修改办法
ctrl + / 添加或取消单行注释
ctrl + shift + / 添加多行注释
ctrl + shit + \ 取消多行注释
ctrl + d 快删除选中的行
ctrl + alt +↑或↓ 快速复制选中的行
ctrl + shift + f 格式化代码
2、方法
2.1、什么是方法
方法：也被称为函数，它是定义在类中的具有特定功能的一段独立小程序，并能被多次使用。
public class Demo {
public static void main(String[] args) {
for( int i = 1 ; i <= 9 ; i++ ) {
for( int j = 1 ; j <= i ; j++ ) {
System.out.print( j + "*" + i + "=" + ( j * i ) + "\t" );
}
System.out.println();
}
/*
* 需要打印的3*3的乘法表
* 需要打印的6*6的乘法表
* 需要打印的7*7的乘法表
*
* 如果需要打印不同方式的乘法表，直接复制上面的代码，会导致程序中的重复代码过多。
* 我们尽可能的想办法将已经存在的代码给复用起来，而不是复制重复的代码。
* 最常见的一种复用：将某些具体独立功能的代码进行单独的包装（封装），然后在需要的使用去调用（使用）。
* 这个种方式就是Java中的函数（方法）。
*/
for( int i = 1 ; i <= 3 ; i++ ) {
for( int j = 1 ; j <= i ; j++ ) {
System.out.print( j + "*" + i + "=" + ( j * i ) + "\t" );
}
System.out.println();
}
for( int i = 1 ; i <= 6; i++ ) {
for( int j = 1 ; j <= i ; j++ ) {
System.out.print( j + "*" + i + "=" + ( j * i ) + "\t" );
}
System.out.println();
}
}
}
2.2、方法的定义格式
/*
* 演示如何自己定义一个方法
*
* 方法的定义格式：
* 修饰符 返回值类型 方法名( 参数类型 变量名 , 参数类型 变量名 ..... ) {
* 方法体;
* }
* 修饰符：目前照着main方法抄写
* 返回值类型 ： 可以是学过的8种基本类型，或者void类型
* 方法名 ：合法的用户标识符
* 参数类型 ：8种基本类型，或者引用类型
* 方法体：就是我们目前所学过的所有代码都可以在其中书写
* 方法签名：就是定义方法的时候开始的格式部分
*
*/
public class MethodDemo {
public static void main(String[] args) {
// 调用自己定义的方法
printCFB( 3 );
printCFB( 6 );
printCFB( 10 );
}
/*
* 下面模拟main方法定义了一个专门用于打印n*n的乘法表
*/
public static void printCFB( int x ) {
for( int i = 1 ; i <= x ; i++ ) {
for( int j = 1 ; j <= i ; j++ ) {
System.out.print( j + "*" + i + "=" + ( j * i ) + "\t" );
}
System.out.println();
}
}
}
注意：方法的返回值类型如果是void时，return语句可以省略不写；void表示的是没有返回值的情况。
2.3、方法练习
需求：需要一个方法，对任意两个int类型数字进行加法运算。
public class Demo {
public static void main(String[] args) {
int sum = getSum( 3 , 4);
System.out.println("sum = "+sum);
}
/*
* 定义方法，计算两个int类型的和值
*/
public static int getSum(int i, int j) {
// 计算和值
int s = i + j;
// 返回和值
return s;
}
}
/*
* 需求：定义功能，计算1~n的和值。
*/
public class MethodDemo2 {
public static void main(String[] args) {
int sum = getSum(5);
System.out.println("sum = " + sum );
//getSum(5);
}
/*
* 根据需求，分析当前这个方法（函数）如何定义：
* 修饰符：目前照着main抄写
* 返回值类型：要根据需求中要求的结果决定，如果仅仅是调用功能，并不需要任何的数据，
* 这时返回值类型必须写void。如果必须有具体的值返回给调用者那么返回值类型必须和返回的那个数据类型一致。
* 方法名：用户自己定义的标识符（不能以数字开始，如果是多个单词从第二个开始首字母大写）。
* 参数：如果定义的方法（函数、功能）仅仅是在完成某个简单的功能，根本不需要外界调用时传递数据，那么参数列表
* 是可以省略不写，直接写一对小括号。如果要接受调用者传递的数据，参数的类型必须和接受的数据类型一致
* ============================
* 如果定义的功能中必须有值返回给调用者，在方法中需要使用return关键字将结果返回去。
*
*/
public static int getSum( int n ) {
// 定义计算和值的空间
int sum = 0;
for( int i = 1 ; i <= n ; i++ ){
sum += i;
}
// 最后需要将和值sum返回给调用者
return sum;
}
}
2.4、方法定义分析
方法代表的是是一个功能，如何才能根据需求写出符合要求的方法呢？
分析上面的代码会发现，定义方法的时候需要考虑两个访问问题：
- 方法是被调用执行，也就是功能运行之后，要不要将运行的一些数据给调用者。
- 方法被调用的时候，要不要接受一些数据作为功能运行的数据。
总结：
如果定义方法需要将结果给调用者，那么就需要在方法中使用return语句，返回具体的数据，那么方法定义时的返回值类型就必须和被返回的数据类型一直。
如果定义的方法运行时需要调用者的数据，那么就需要在定义方法的时候在方法上定义参数，接收传递的数据。
2.5、练习
需求：计算1-500(包含500)之间的所有能被3和7整除数之和。
/*
* 需求：定义功能，判断某个数字是不是素数（质数）。
*/
public class MethodDemo3 {
public static void main(String[] args) {
for (int i = 2; i <= 100 ; i++) {
boolean b = isSuShu2( i );
System.out.println( i + "....." + b );
}
}
public static boolean isSuShu2( int x ){
for( int i = 2 ; i < x ; i++ ){
// 判断
if( x % i == 0 ){
// 只要i能够将x除尽，说明已经找到一个，不用再循环了
return false ;
}
}
return true;
}
/*
* 分析如何定义方法：
* 返回值类型：是一个判断的结构，应该是boolean类型
* 参数列表：被判断的那个数字。int类型
*/
public static boolean isSuShu( int x ){
/*
* 素数（质数）：只能被1和本身整除的数字。
* 其实就是说从2到本身-1之间没有任何一个数字能够将其除尽。
* 使用循环提供2到本身-1的每个数字，在提供的过程中如果有任何一个数字能够
* 将当前这个数字除尽，说明除去1和本身之外找到第三个数字，当前这个数就不是素数，
* 那么我们也没有必须要继续找其他可以除尽的数字了。
*/
int temp = 2;
for( int i = 2 ; i < x ; i++ ){
// 判断
if( x % i == 0 ){
// 只要i能够将x除尽，说明已经找到一个，不用再循环了
break;
}
temp++;
}
/*
* 循环结束了，有两种情况：
* 1、找到了一个可以除尽的数据，通过break结束的
* 2、一直没有找到，是i == x 的时候结束的。
*/
if( temp == x ){
return true;
}else{
return false;
}
}
}
2.6、方法的重载(overload)
2.6.1、重载的引入
两个数相加，需要一个方法名字getSum，三个数相加需要一个方法名字getSum2，那如果有100个数相加，不是就需要getSum100了？那是不是在调用方法的时候还需要去记住哪个方法名对应多少个参数？这很显然是不可能的了。java为我们提供了重载这个机制，使用重载就可以解决这个问题。
2.6.2、重载的概念
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可，这时就形成了重载。重载和返回值类型无关。
2.6.3、重载举例
/*
* 演示 方法的重载（overload）:
* 1、一般出现方法的重载：在同一个类中出现的功能类似的方法，然后方法名相同。
* 2、方法要重载，必须保证的内容：方法名相同、参数列表不同。
* 参数列表不同：
* 1）参数的类型不同。
* 2）参数的个数不同。
* 3）参数的类型和个数都不同。
*/
public class MethodDemo4 {
public static void main(String[] args) {
}
/*
* 计算两个int数的和值
*/
public static int getSum( int a , int b){
return a + b;
}
/*
* 计算3个int数的和值
*/
public static int getSum( int a , int b , int c){
return a + b + c;
}
/*
* 计算两个double数的和值
*/
public static double getSum( double c , double d ){
return c + d ;
}
}
2.6.4、重载练习题
void show(int a,float b,char c){ }
下列哪些函数和给定函数可以在一个类中重载？
a.int show(int x,float y,char z) //没有重载，这个函数不允许和给定函数存在于同一个类中。因为会产生调用的不确定性。
b.void show(float b,int a,char c) //重载了，参数类型不同。
c.void show(int c,float a,char b) //没有重载，和给定函数一样。不允许存在。
d.void show(int a,int b,int c) //重载了，因为类型不同。
e.double show() //重载了，因为个数不同。
2.7、函数命名规范
在定义函数时，函数名名不能使用关键字和保留字。
回忆类名的定义规范：单词的首字母大写，采用驼峰式；由有实际意义的名词或名词短语构成：如：Student, StudentScore,
函数名规范：第一个单词的首字母小写，采用驼峰式；由有实际意义的动词或动词短语。如：getSum。
3、数组
3.1、为什么用数组
经过前面的学习，知道了变量空间是可以存放数据的，但是每一个变量空间只能存放一个数据，可是当数据非常多的时候怎么办？比如全班同学的年龄，年龄是一个int类型的数据，可以开辟int空间存放。可是全班这么多同学，难道我们都要一个一个变量空间去定义再存放数据吗？Java有没有提供其他的方式可以存放同一类型的多个数据呢？Java中提供了数组来解决上面的问题。
3.2、数组的概念
数组是同一种类型数据的集合；即能够存放多个相同类型的数据的容器。
3.3、数组的定义方式
数组是存放多个数据的容器，Java中需要使用new关键字来创建容器，在创建容器时也要明确容器的大小，即容器中存放数据个数。
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
int[] arr = new int[3];//通过new关键字创建了一个长度为3，元素类型是int的数组实体。
3.4、数组的好处
数组可以存储多个数据，而且可以对数据进行编号，从0开始。操作元素完成可以通过编号(索引index)完成。
int[] arr = new int[3];
arr[0] = 3; //给数组编号(角标)为0的空间中存放int类型的常量值3
System.out.println(arr[1]);//输出数组编号为1空间中的值。
/*
* 讲解数组：
* 数组：数据的组合。有很多的数据。
* 在Java中存储数据需要的变量空间：
* 如果数据较小，可以直接定义单个的变量存储。但是如果数据量较多，比如100个int类型的数据
* 这时就不可能在程序中手动的定义100个int类型的空间。
* 我们就需要能够在内存中一次定义出多个空间，然后存储这些数据。
* 在java中可以采用数组来解决上面的问题。
*
* 什么是数组：
* 在内存中可以一次性的创建出很多的存储空间，并且可以采用统一的方式去操作这些空间。
* 定义数组的格式：
* 数据类型[] 数组名 = new 数据类型[数组空间个数];
* 数据类型[] 数组名 ; 仅仅只是定义了一个数组类型的变量
* 数据类型：8种基本类型，或者后面学习的引用类型
*/
public class ArrayDemo {
public static void main(String[] args) {
/*
* 定义拥有5个int类型空间的数组
* 在定义数组的时候，new double[5] 中括号中的数字表示的当前
* 需要创建的数组的空间个数。
*/
double[] arr = new double[5];
// [I@15db9742 它表示当前arr是一个数组
System.out.println( arr );
/*
* 数组的使用必须通过数组的名和数组的下标使用
* 只要定义好数组，数组每个空间就有固定的下标，下标从0开始，
* 第一个空间的下标为0，
* 第二个空间的下标为1，
* 最后一个空间应该是数组的长度-1.
*/
// 数组定义好之后，通过数组名操作数组时中括号中的数字是每个空间的下标
arr[0] = 12.3;
arr[2] = 3.3;
arr[3] = 5.5;
// 如何将数组中的数据取出呢？
System.out.println(arr[0]);
// 要操作数组的每个空间，一般都会使用循环提供数组的下标，采用数组名和下标的方式操作
for( int i = 0 ; i < 5 ; i++ ) {
System.out.println( arr[i] );
}
}
}
3.5、Java的内存分配
Java对内存空间的划分：五部分：栈，堆，方法区，本地方法区，寄存器。
栈内存：它主要是用来运行我们的方法的。方法运行在栈中。
堆内存：只要是通过new关键字创建出来的玩意，都在堆中。只要是在堆中的空间，它们及时不赋值，也会有默认值。int默认值0，double默认值0.0,引用类型默认null。char类型默认’\u0x00’
方法区：当执行java命令的时候程序会被从硬盘上先加载对应的class文件到方法区内存中，常量池、静态区等等。
本地方法区：它我们用不了，是给JVM调用native的方法使用的。
寄存器：是给CPU用的。
3.6、数组的内存分配
int[] arr = new int[3];
arr = null;
图解说明：程序执行main方法时，会先在堆内存中开辟数组空间，并为其分配内存地址0x34(假设)。数组各个空间都有默认的编号（角标或索引），接着给数组各个存储空间默认初始化为0。到底数组创建结束，将数组的内存地址赋值给main方法的数组引用变量arr。程序继续执行，将arr引用变量赋值为null，即arr不再指向堆中的数组实体。这时这个数组实体将会变成垃圾，等待垃圾回收机制收走。
3.7、数组的常见问题
3.7.1、数组角标越界异常
ArrayIndexOutOfBoundsException：访问到了数组不存在的索引时，会发生该异常。
/*
* 介绍数组操作中最常见的两个问题：
* 1、数组角标（下标、索引index）越界。
* 每个数组定义好之后都有自己的下标，它们的下标从0开始，到长度-1结束。
* 如果我们操作的时候下标不在这个范围中，就称为下标（角标）越界
*/
public class ArrayDemo2 {
public static void main(String[] args) {
// 定义数组
int[] arr = new int[5];
// 给下标为0空间存放数据
arr[0] = 123;
// 有问题，数组中没有下标-1
//arr[-1] = 123;
// 下标为5的空间不存在
arr[5] = 345;
}
}
3.7.2、空指针异常
NullPointerException:当使用没有任何实体指向的引用变量操作实体时，运行会发生该异常。
/*
* 数组操作中的 ： 空指针异常（问题）：NullPointerException
*/
public class ArrayDemo3 {
public static void main(String[] args) {
// 定义数组
int arr[] = new int[5]; // int[] arr = new int[5];
// 给数组下标为3的空间存放数据
arr[3] = 123;
/*
* 将arr变量空间中的地址替换成null，
* arr不再指向堆中的数组的真实空间了
*/
arr = null;
/*
* 如果将某个引用变量赋值null，那么就表示这个变量不再指向堆中的任何空间
* 也就是无法再想通过引用变量去操作堆中的内容了。
* 如果还企图去使用，就会发生空指针异常。
*/
arr[2] = 222;
}
}
3.8、数组的练习
3.8.1、遍历数组
/*
* 数组的练习：
* 遍历（访问）数组的每个空间。
*/
public class ArrayTest {
public static void main(String[] args) {
/*
* 第一种：
* 数据类型 [] arr = new 数据类型[长度];
* 数组的第二种定义格式：
* 数据类型 [] arr = {值,值, ...........};
*/
//int[] arr = new int[10];
int[] arr = { 11 , 22 , 33 , 0 , -7 , 5 , 3 };
/*
* 数组只要定义好了，它不仅仅拥有下标，
* 还拥有一个length的变量，它记录着当前数组中有多少个数据
*/
//System.out.println( arr.length);
for( int i = 0 ; i < arr.length ; i ++ ){
System.out.println("arr[" + i + "]=" + arr[i]);
}
}
}
3.8.2、数组求和
/*
* 演示数组求和运算
*/
public class ArrayTest2 {
public static void main(String[] args) {
int[] arr = { 1, 5, 2, 11, 66, 44, 23, 67, 87 };
// 定义sum变量，用来存放累加和
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
System.out.println("数组中数据的总和：" + sum);
// 计算数组中的奇数和和偶数和
int oddSum = 0 , evenSum = 0;
for (int i = 0; i < arr.length; i++) {
// 判断从数组中取出的数据是奇数还是偶数
if( arr[i] % 2 == 0 ){
evenSum += arr[i];
}else{
oddSum += arr[i];
}
}
System.out.println("数组中奇数的和值是："+oddSum);
System.out.println("数组中偶数的和值是："+evenSum);
}
}
3.8.3、数组求最值
/*
* 通过方法，定义对数组求最值练习。
* 最值：
* 最大值：
* 最小值：
* 最值解决的时候，需要找一个参照物，然后遍历数组中的每个数据，取出每个值和参照物进行比较
* 取出的值比参照物大，就换，这样找出的就是最大的。或者比参照物小，就换，找出的就是最小的。
*/
public class ArrayTest3 {
public static void main(String[] args) {
// 定义数组
int[] arr = { 11, 6, 44, 1, 5, 2, 2 ,3, 6 ,7, 8 ,4 };
// 调用方法
int max = getArrayMax( arr ); // ctrl + 1
System.out.println("数组中的最大值是：" + max);
int min = getArrayMin( arr );
System.out.println("数组中的最小值是：" + min);
}
/*
* 求int数组中的最小值
*/
public static int getArrayMin(int[] arr) {
int min = arr[0];
for (int i = 0; i < arr.length; i++) {
if( min > arr[i] ){
min = arr[i];
}
}
return min;
}
/*
* 定义方法，找出指定数组中的最大值
*/
public static int getArrayMax(int[] arr) {
// 定义一个变量，作为参照物（假设一个值作为最大值）
int max = arr[0]; //假设数组中的第一个值为最大值
for( int i = 0; i < arr.length ; i++ ){
// 判断
if( max < arr[i] ){
// 判断成立，说明数组有某个空间的值比假设的大
max = arr[i];
}
}
return max;
}
/*
* 找出最大值所在的下标
*/
public static int getArrayMax2(int[] arr) {
// 假设第一个空间的下标（也是在假设第一个空间为最大值）
int maxIndex = 0;
for( int i = 0; i < arr.length ; i++ ){
// 判断
if( arr[maxIndex] < arr[i] ){
maxIndex = i ;
}
}
return arr[maxIndex];
}
}
3.8.4、数组反转
/*
* 演示数组的反转(转置)
*/
public class ArrayTest4 {
public static void main(String[] args) {
int[] arr = { 11, 22, 33, 44, 55, 66 , 77 };
printArray(arr);
reverseArray(arr);
printArray(arr);
demo();
}
// 打印数组
public static void printArray( int[] arr ){
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
System.out.println();
}
// 反转数组
public static void reverseArray(int[] arr) {
for (int i = 0 , j = arr.length - 1 ; i <= j ; i++ , j-- ) {
int t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
}
// 演示互换两个空间中的数据
public static void demo(){
int a = 3;
int b = 4;
System.out.println("a = " + a + ", b = " + b);
int t = a;
a = b ;
b = t;
System.out.println("a = " + a + ", b = " + b);
}
}
3.8.5、数组的查找
/*
* 数组的查找功能：
* 定义功能，从指定的数组中找出指定的数据，如果有就告诉调用者数据的下标，如果没有，就返回-1。
*/
public class ArrayTest5 {
public static void main(String[] args) {
int[] arr = {11,22,33,44,55,66,77,88,99};
int index = getIndex(arr , 34 );
System.out.println("index = "+index);
index = getIndex2(arr ,67);
System.out.println("index = "+index);
}
// 折半查找（二分查找）
public static int getIndex2( int[] arr , int key){
int start = 0;
int end = arr.length - 1 ;
int mid = (start + end) / 2;
// 只要开始的start下标比end下标小，就说明可以继续折半
while( start < end ){
// 判断中间的值和key的关系
if( arr[mid] == key ){
return mid;
}
if( arr[mid] < key ){
start = mid + 1;
}
if( arr[mid] > key ){
end = mid - 1;
}
// 从新计算中间的下标
mid = (start + end) / 2;
}
return -1 ;
}
// 普通查找
public static int getIndex(int[] arr , int key) {
/*
* 将数组遍历一遍，取出每个值和指定的key比较
* 如果相等就说明找了，立刻将这个下标返回。循环到此就结束。
* 如果将数组都遍历完了，都没有找到，那么就应该返回-1
*/
for (int i = 0; i < arr.length; i++) {
// 判断取出的值是否等于key
if( arr[i] == key ){
return i;
}
}
return -1;
}
}
3.8.6、数组排序(不要求)
数据的排序：升序、降序。
在编程语言中排序算法：
/*
* 演示 关于数组的排序（选择排序、冒泡排序）
*/
public class ArrayTest6 {
public static void main(String[] args) {
int[] arr = {3,1,7,4,6,0,8,5};
printArray(arr);
bubbleSort(arr);
printArray(arr);
}
/*
* 冒泡排序
*/
public static void bubbleSort( int[] arr ){
for( int i = 0 ; i < arr.length-1 ; i++ ){
for( int j = 0 ; j < arr.length - 1 - i ; j ++ ){
if( arr[j] > arr[j+1] ){
int t = arr[j];
arr[j] = arr[j+1];
arr[j+1] = t;
}
}
}
}
/*
* 选择排序
*/
public static void selectSort( int[] arr ){
// 外层循环用于提供被选择的空间的下标
for (int i = 0; i < arr.length - 1; i++) {
// 提供已经选中的空间后面剩余的所有空间下标
for( int j = i + 1; j < arr.length ; j++ ){
if( arr[i] < arr[j] ) {
int t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
}
}
}
// 打印数组
public static void printArray( int[] arr ){
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
System.out.println();
}
}
4、Arrays数组工具介绍
上面介绍了数组的一些练习，而针对数组的常见操作，Java已经提供好了，并书写在Arrays中。在程序中是可以直接使用的。
public class Demo {
public static void main(String[] args) {
// 定义数组
int[] arr = { 23, 15, 67, 25, 90, 33 };
// 打印数组
System.out.println( Arrays.toString(arr) );
// 数组排序
Arrays.sort(arr);
System.out.println( Arrays.toString(arr) );
}
}
程序运行结果：
