黑马程序员-----java基础------for循环结构----do...while循环----while循环------方法---数组（一维,二维）

------<a href="http://www.itheima.com"
target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------
 
循环结构的分类：

 

for循环：

 for循环语句格式：

 for(初始化语句;判断条件语句;控制条件语句) {

         循环体语句;

    }

 执行流程

  A:执行初始化语句

  B:执行判断条件语句，看其结果是true还是false

  如果是false，循环结束。

  如果是true，继续执行。

  C:执行循环体语句

  D:执行控制条件语句

  E:回到B继续

(理解)while循环

 while循环语句格式：

  基本格式

   while(判断条件语句) {

     循环体语句;

   }

  扩展格式

   初始化语句;

   while(判断条件语句) {

     循环体语句;

     控制条件语句;

   }

 执行流程

  A:执行初始化语句

  B:执行判断条件语句，看其结果是true还是false

  如果是false，循环结束。

  如果是true，继续执行。

  C:执行循环体语句

  D:执行控制条件语句

  E:回到B继续

(了解)do..while循环

 do…while循环语句格式：

  基本格式

     do {

     循环体语句;

     }while((判断条件语句);

  扩展格式

     初始化语句;

     do {

     循环体语句;

     控制条件语句;

   } while((判断条件语句);

三种循环的区别：

 区别：

  do…while循环至少会执行一次循环体

  for循环和while循环只有在条件成立的时候才会去执行循环体

 

 注意事项：

  如果循环结束后，要需要使用初始化变量，请使用whlie,否则使用for

  推荐使用for循环，因为for循环执行完后后，初始化变量就会在内存中消失了。提高内存效率

  

循环嵌套：

 循环中包含另一个循环

  for(){

   for(){

    

   }

  }

  

控制跳转语句:

 break: 结束当前循环，程序执行循环后面的代码

 continue:结束本次循环，继续下一次循环

return: 结束当前方法，return后面的语句不执行 

 

    

  

1、什么是方法（Method）？

方法是一组为了实现特定功能的代码块的集合。方法在语法上的功能主要有以下两个：

①：结构化代码

将代码按照功能进行组织，使代码的结构比较清晰，容易阅读和修改，也就是程序的可维护性强。

②：减少代码重复

一个固定的功能，可能会在程序中多次使用，在使用时只需要调用写好的方法，而不用重复书写对应的功能代码。

方法在书写时需要注意以下两点：

①：逻辑严谨

方法实现的一个完整的功能，所以在书写时要考虑到各种可能的情况，并对每种情况做出恰当的处理。

②：通用性强（可重复利用）

方法实现的是一种功能，在实际实现时，可以根据需要，使方法具备一定的通用性，除非必要，否则不要写专用的方法。在Java语言中，恰当的使用方法，将使程序更加优雅，便于阅读和使用。

我的总结：

方法：一段可重复使用的代码段；

程序中完成独立功能的一段代码的集合。

 

2方法格式

[修饰符]返回值类型 方法名([参数类型 形式参数1，参数类型
形式参数2，……])

{

执行语句; [return返回值;]//需要的话

}

参数列表（参数的类型 ，参数的个数，参数的顺序）

我的总结：只要上述有一个不一样，那么这个参数列表就不一样！对于方法而言，即使同名也不是同一个方法，也就是下面讲的方法签名。

3、方法里的属性方法里面的属性

访问控制符：访问控制符限定方法的可见范围，或者说是方法被调用的范围。方法的访问控制符有四种，按可见范围从大到小依次是：public、protected，无访问控制符,private。其中无访问控制符不书写关键字即可。具体的范围在后续有详细介绍。

形式参数：在方法被调用时用于接收外界输入的数据。

实参：调用方法时实际传给方法的数据。

返回值：方法在执行完毕后返还给调用它的环境的数据。

返回值类型：事先约定的返回值的数据类型，如无返回值，必须给出返回类型
void。

方法签名：方法名和方法的参数列表(能区别方法)；//最关键的

java语言中调用方法：对象名.方法名（实参列表）。

实参的数目、数据类型和次序必须和所调用方法声明的形参列表匹配。

return 语句终止方法的运行并指定要返回的数据。

 

4方法特点

它可以实现独立的功能;

必须定义在类里面;

它只有被调用才会执行;

它可以被重复使用;

方法结束后方法里的对象失去引用;

如何定义一个功能,并通过方法体现出来：

①　明确该功能运算后的结果.明确返回值类型<
10972
/span>;

②　明确在实现该功能过程中是否有未知内容参与运算，确定参数列表;

Eg：

package reviewDemo;

/**

* player 的值分别是1,2,3或者其他值时，该方法返回“大明”，“二明”，“小明”，“我没有这个孩子”。

*/

 

<span style="font-size:18px;"><span style="font-size:18px;">
public class Demo2 {

public static void main(String[] args) {

int player = 5;

System.out.println("返回的结果是："+show(player));

}

public static String show(int p){

switch (p) {

case 1:

return "大明";

case 2:

return "二明";

case 3:

return "小明";

default:

return "我没有这个孩子！";

}

}

}
</span></span>

 

 注意：

  1：方法不调用，不执行

  2：方法与方法是平级关系，不能嵌套定义

  3：方法定义的时候参数之间用逗号隔开

  4： 方法调用的时候不用在传递数据类型

  5： 如果方法有明确的返回值，一定要有return带回一个值

  6： 如果方法没有明确返回值，请使用void来表示方法返回类型

    void空类型

    定义一个变量的时候，不能定义void类型变量

  7: 如果方法的返回值是void类型，那么该方法的return语句可以省略

    要是相加的话， 请使用 return ;

  

 如何写一个方法呢?两个明确

  返回值类型 明确功能结果的数据类型

  参数列表 明确有几个参数，以及参数的类型

 

 

 

 5、什么是方法的重载（Overload）？

概念：

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型或参数顺序不同即可。

存在的原因：

屏蔽了一个对象的同一类方法由于参数不同所造成的差异。

特点：

与返回值类型无关，只看参数列表。

以下是方法重载的示例：
public void a(int a){}
public int a(){}
public void a(int a,String s){}

Eg：

<span style="font-size:18px;"><span style="font-size:18px;">public class Demo6 {

public static void main(String[] args) {

int[]age = {1,2,3,69,36,636,459};

show(age);

}

public static void show(int...a){//此时这里写的就是可变参数，和数组的作用一样！

//把数组给打印出来！

System.out.println(Arrays.toString(a));

}

}
</span></span>

 

我的总结：方法重载，方法名相同，但是参数列表不一致！（和方法覆写不一样，方法覆写的方法名和参数列表都必须一样），注意方法重载和方法覆写的不同！

6可变参数

从java5开始出现了可变参数，这是对java方法及数组的拓展！

方法中可以接受的参数不再是固定个数的，而是随着具体需求传递的多少来决定。

定义格式： 返回值类型  方法名(参数类型...形式参数){
}

可变参数的特点：

只能出现在参数列表的最后；

... 位于变量类型和变量名之间，前后有无空格都可以;

调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。

Eg：

package reviewDemo;

import java.util.Arrays;

<span style="font-size:18px;"><span style="font-size:18px;">public class Demo6 {

public static void main(String[] args) {

int []age = {1,2,3,69,36,636,459};

show(age);

}

public static void show(int...a){//此时这里写的就是可变参数，和数组的作用一样！

//把数组给打印出来！

System.out.println(Arrays.toString(a));

}

}
</span></span>

 Java中的参数传递

 实际参数：调用方法时，使用的参数就是实际参数，如下面的a,b

  getMax(a,b);

  

  int[] arr = {1,2,3};

  change(arr);

 形式参数：定义方法时，参数列表中的参数,如下面的x,y

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

   x = 200;

   y = 100;

  }

  

  public static void change(int[] arr){

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

    arr[i] *= 2;

   }

  }

  

 结论：

  如果调用方法时，使用的参数是基本数据类型的值

  那么，形式参数(x,y)的改变 对 实际参数(a,b)没有影响

  

  如果调用方法时，使用的参数是引用数据类型的值

  那么，形式参数的改变 对 实际参数有影响

7数组

数组：

 概念：数组是存储同一种数据类型多个元素的容器

     数组就是一个框，里面可以存储多个相同类型的元素

 如何访问数组中的元素呢？

  可以通过数组名下标的方式访问

   格式: 数组名[索引]

 

 数组的格式1：

  数据类型[] 数组名；

  数据类型 数组名[];

  

  格式：数据类型[] 数组名 = new 数据类型[数组长度];

 数组的格式2：

  数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};

数组常见问题：

 数组索引越界

  ArrayIndexOutOfBoundsException

  访问到了数组中的不存在的索引时发生。

 空指针异常

  NullPointerException

  数组引用没有指向实体，却在操作实体中的元素时。

 

数组(Array)是Java语言中内置的一种基本数据存储结构，通俗的理解，就是一组数的集合，目的是用来一次存储多个数据。数组是程序中实现很多算法的基础，可以在一定程度上简化代码的书写。

备注：

1. 数组的好处：数组里的每个元素都有编号，编号从0开始，并且依次递增，方便操作这些元素；

2. 使用Java数组：必须先声明数组，再给该数组分配内存；

3. 数组对应在内存中一段连续空间。

4. 数组元素必须是相同数据类型，也可以是引用数据类型，但是同一个数组中的元素必须是同一类数据类型。

 8 一维数组

一维数组：可以理解为一列多行、类型相同的数据，其中每个数据被称为数组元素；

一维数组的声明方式：

  type varName[]; 或
type[] varName;(推荐)

Eg：int age[]; int []age;

数组的长度一旦确定,就不能改变,也就数组是定长的;

我的总结：java语言声明数组的时候不能指定其长度（元素的个数）

Eg：int a[5]; //非法

初始化：

Java中的数组必先初始化才可以使用，所谓初始化就是为数组的数组元素分配内存，并为每个数组元素赋值；

数组初始化的两种方式：

静态初始化：初始化时由我们自己指定每个数组元素的初始值，由系统决定需要的数组长度；

格式：数组名
= new 数组类型[]{元素1,元素2,元素3...元素n};

简化语法：数组名
= {元素1,元素2,元素3...元素n};

动态初始化：初始化时由我们指定数组的长度，由系统为数组元素分配初始值；

格式：数组名
= new 数组类型[数组长度];

我的总结：

不能静态和动态初始化同时使用：

也就是说不能同时指定数组的长度和元素；

Eg:

package reviewDemo;

/**

* 声明数组及初始化

*/

<span style="font-size:18px;"><span style="font-size:18px;">public class Demo3 {

public static void main(String[] args) {

int []age = new int[10];

//动态初始化

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

age[i] = i;

System.out.print(age[i]+"     ");

}

}

}
</span></span>

 

输出：0     1     2     3     4     5     6     7     8     9    

 

Java语言的数组索引是从0开始的，也就是说数组里的第一个元素的索引是0,第二个元素的索引是1，依次可以类推。

常见操作：

给数组元素赋值

数组名[索引] =数组类型的值;

访问数组元素

数组类型 变量
= 数组名[索引];

得到数组的长度

int len  = 数组名.length; //length是数组的属性

遍历数组（备注：length 属性和循环语句）

数组元素的索引范围（0，长度—1）

Eg：判断数组是否重复

package reviewDemo;

/**

* 判断数组是否重复

<span style="font-size:18px;"><span style="font-size:18px;">public class Demo3 {

public static void main(String[] args) {

int []age = {1,2,3,4,5,6,5};

for (int i = 0; i < age.length-1; i++) {//双层循环，定住一个，再考虑下一个！

for (int j = i+1; j < age.length; j++) {

if(age[i] == age[j]){

System.out.println("有重复的！"+i+"  "+j);

break;

}

}

}

}

}
</span></span>

 

求最大值值

<span style="font-size:18px;"><span style="font-size:18px;">public class Demo4 {

public static void main(String[] args) {

int age[] = new int[] { 12, 26, 3, 60, 55, 6, 48, 4, 98 };

int max = age[0];

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

if (max < age[i]) {

max = age[i];

}

}

System.out.println(max);

}

}
</span></span>

 

经典用法：冒泡法排序

package reviewDemo;

import java.util.Arrays;

//冒泡排序

<span style="font-size:18px;"><span style="font-size:18px;">public class Demo6 {

public static void main(String[] args) {

int []age = {1,2,36,363,56,95,12,32,1232,3263};

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

for (int j = i+1; j <= age.length-1; j++) {

if(age[i] > age[j]){

int temp = age[i];

age[i] = age[j];

age[j] = temp;

}

}

}

System.out.println(Arrays.toString(age));

}

}
</span></span>

 

//输出为：[1, 2, 12, 32, 36, 56, 95, 363, 1232, 3263]

 

 

 

二维数组

 概念：其实就是一个元素为一维数组的数组。

   大框里 存放着多个小框，每个小框中存放着多个苹果

   

 格式1：

  数据类型[][] 变量名 = new 数据类型[m]
;

 

  m表示这个二维数组有多少个一维数组

  n表示每一个一维数组的元素个数

  int[][] arr = new int[3][2];

 格式2：

  数据类型[][] 变量名 = new 数据类型[m][];

  

  m表示这个二维数组有多少个一维数组

  这一次没有直接给出一维数组的元素个数，可以动态的给出。

  int[][] arr = new int[3][];

  arr[0] = new int[2];

  arr[1] = new int[3]

  arr[2] = new int[1];

 

 格式3：

  数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};

  

  简化版格式：

  数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};

  int[][] arr =  {{1,2,3},{4,6},{6}};

打印杨辉三角形(行数可以键盘录入)

 

 1

 11

 121

 1331

 14641

 .......

 规律：

  两边赋值规律：

   1

   11

   1*1

   1**1

   1***1

   arr[i][0] = 1;

   arr[i][i] = 1;

  中间赋值规律：

   arr[i][j] = arr[i-1][j-1] + arr[i-1][j]

  打印规律：

  *

  **

  ***

  ****

  for (int i=0; i<=n; i++) {

   for (int j=0; j<=i; j++) {

    SOP("*");

   }

   System.out.println();

  }

*/

<span style="font-size:18px;">import java.util.Scanner;
class Array2Test3 {
public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);

System.out.println("请输入杨辉三角形的行数：");
int row = sc.nextInt();

//创建二维数组，用来存储图形
int[][] arr = new int[row][row];

//两边赋值规律：
for (int i=0; i<row; i++) {
arr[i][0] = 1;
arr[i][i] = 1;
}

//中间赋值规律:
for (int i=2; i<arr.length; i++) {
//arr[0],arr[1] 一维数组
for (int j=1; j<i; j++) {
//arr[i][j] 具体一维数组的元素
arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
}
}

//打印图形
printArray( arr );
}

//打印图形
public static void printArray(int[][] arr){
for (int i=0; i<arr.length; i++) {
//arr[0]...
//for (int j=0; j<arr[i].length; j++) {
for (int j=0; j<=i; j++) {
//arr[i][j] 元素值
System.out.print(arr[i][j] + "\t");
}
System.out.println();//换行
}
}
}</span>

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

import java.util.Scanner;
class Array2Test3 {
public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);

System.out.println("请输入杨辉三角形的行数：");
int row = sc.nextInt();

//创建二维数组，用来存储图形
int[][] arr = new int[row][row];

//两边赋值规律：
for (int i=0; i<row; i++) {
arr[i][0] = 1;
arr[i][i] = 1;
}

//中间赋值规律:
for (int i=2; i<arr.length; i++) {
//arr[0],arr[1] 一维数组
for (int j=1; j<i; j++) {
//arr[i][j] 具体一维数组的元素
arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
}
}

//打印图形
printArray( arr );
}

//打印图形
public static void printArray(int[][] arr){
for (int i=0; i<arr.length; i++) {
//arr[0]...
//for (int j=0; j<arr[i].length; j++) {
for (int j=0; j<=i; j++) {
//arr[i][j] 元素值
System.out.print(arr[i][j] + "\t");
}
System.out.println();//换行
}
}
}