------
Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
1. 程序流程控制
1.1 循环结构
For循环嵌套规律总结：
在用嵌套结构打印三角图形时，外循环控制的行数，内循环控制列数。
尖朝上可以改变条件，让条件随着外循环变化；
尖朝下可以改初始化值，让初始化值随外循环变化；
示例1：
package com.blog.part1;
public class ForDemo
{
public static void main(String[] args)
{
for(int x = 0; x < 3; x++)
{
for(int y = 0; y < 4; y++)
{
System.out.print(" ok " );
}
}
}
}
运行结果：
示例2：
package com.blog.part1;
/**
* 需求：用“*”打印一个长方形。
* @author jinlong
* */
class ForSquareDemo
{
public static void main(String[] args)
{
for(int x = 0; x < 4; x++)
{ //外循环控制的是行数
for(int y = 0; y < 5; y++)
{//内循环控制的是每一行的个数
System.out.print("*" );
}
//这里的打印是为了换行:注意print和println区别
System.out.println();
}
}
}
运行结果：
练习1：
/**
* 需求：打印出下格式的内容：
*****
****
***
**
*
思路：一共五行，但是每行*个数在逐渐减少，可以用内循环控制
* @author jinlong
* */
package com.blog.part1;
public class ForTriangleDemo
{
public static void main(String[] args)
{
//用嵌套循环，外循环表示行数，可知有五行
for(int x = 0; x < 5; x++)
{
//内循环表示每行个数，改变初始化值
for(int y = x; y <= 5; y++)
{
System.out.print("*" );
}
//换行
System.out.println();
//
}
}
}
运行结果：
练习2：
/**
* 需求：打印出下格式的内容：
*
**
***
****
*****
*
*@author jinlong
*/
package com.blog.part1;
public class ForTriangleDemo1
{
public static void main(String[] args)
{
//用嵌套循环，外循环表示行数，可知有五行
for(int x = 0; x < 5; x++)
{
//内循环表示每行个数，个数从小到达变化
for(int y =0 ; y <=x ; y++)
{
System.out.print("*" );
}
//换行
System.out.println();
//
}
}
}
运行结果：
练习3：
/**
* 需求：打印出下格式的内容：
54321
5432
543
54
5
* 思路：这个类似与三角图形，不同的是，把“*”变成了不断变化的数字。
* 可以按照打印倒三角方式打印，每行数字是有递减规律的
* */
package com.blog.part1;
public class ForNumDemo
{
public static void main(String[] args)
{
for(int x = 0; x < 5; x++)
{
//尖朝下，改变内循环初始化值
for(int y = x; y <5; y++)
{
//因为每行数字是递减的
System.out.print(5-y);
}
System.out.println();
}
}
}
运行结果：
练习4：
/**
* 需求：打印出下格式的内容：
1
22
333
4444
55555
思路：首先是三角型，想到for嵌套，然后尖朝上，可以改变内循环条件。
值随着行数增加，但是同一行每列相同，其实就是打印的行号
* @author jinlong
* */
package com.blog.part1;
public class ForNumDemo1 {
public static void main(String[] args)
{
// TODO Auto-generated method stub
for(int x = 1; x <= 5; x++)
{
//改变条件随外循环变化
for(int y = 1; y <= x; y++)
{
//打印的行号
System.out.print(x);
}
System.out.println();
}
}
}
运行结果：
练习5：
/**
* 需求：打印九九乘法表成如下形式：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
...
思路：把（1*1=1）看成一个元素，也可以当成正三角打印
再具体分析每一个元素的值变化规律
* @author jinlong
**/
package com.blog.part1;
public class For99Demo {
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+"="+(i*j)+"\t");
}
System.out.println();
}
}
}
运行结果：
P.S.
1、代码中的"\t"是一个转义字符，也就是制表符。还有其他的一些转义字符：\n:回车，\b:退格，\r:回车符。
2、windows系统中回车符其实是由两个转义字符组成的：\r\n，linux中回车符是\n。
例子：
1、代码中的"\t"是一个转义字符，也就是制表符。还有其他的一些转义字符：\n:回车，\b:退格，\r:回车符。
2、windows系统中回车符其实是由两个转义字符组成的：\r\n，linux中回车符是\n。
例子：
打印"hello world"：
System.out.println("\"hello word\"");
System.out.println("\"hello word\"");
打印\hello world\：
System.out.println("\\hello word\\");
练习6：
/**
* 需求：打印出下格式的内容：等腰三角形
* * * * *
* * * *
* * *
* *
*
* 思路：等腰三角形，可以转变成两个三角形，如下形式
* -* * * * *
* - -* * * *
* - - -* * *
* - - - -* *
* - - - - -*
* 代码形式，就是一个for嵌套两个for循环块。
* 改变“*”之间的距离就可以变成等腰三角形，就是题目要求
* @author jinlong
* */
package com.blog.part1;
public class ForTriangleDemo3 {
public static void main(String[] args)
{
//外循环结构，五行
for (int x=0;x<5 ;x++ )
{
//第一个内循环打印虚线三角形
for (int y=0; y<=x ;y++ )
{
//这里注意，可以用空格代替虚线
System.out.print(" ");
}
//这里打印* 三角形
for (int z=x;z<5 ;z++ )
{
//这里只要在*右边加一个空格就可以变为等腰形
System.out.print("* ");
}
System.out.println();
}
}
}
运行结果：
1.2其他流程控制语句
break(跳出)，continue(继续)。
1.2.1、break语句：
应用范围：选择结构和循环结构。
示例1：
/**
* @author jinlong
* */
package com.blog.part1;
public class BreakDemo
{
public static void main(String[] args)
{
for(int x=0;x<3;x++)
{
System.out.print("x="+x);
break;
}
}
}
运行结果：
示例2
/**
* @author jinlong
* */
package com.blog.part1;
public class BreakDemo1
{
public static void main(String[] args)
{
for(int x=0;x<3;x++)
{
for(int y=0;y<4;y++)
{
System.out.println("x="+x);
break;
}
}
}
}
运行结果：
1.2.2continue语句
应用范围：循环结构。continue语句是结束本次循环继续下次循环。
示例1
/**
* @author jinlong
* */
package com.blog.part1;
public class ContinueDemo
{
public static void main(String[] args)
{
for(int x=0;x<3;x++)
{
for(int y=0;y<4;y++)
{
System.out.println("x="+x);
continue;
}
}
}
}
总结：
1、这两个语句离开应用范围，存在是没有意义的。
2、这个两个语句单独存在，下面都不可以有语句，因为执行不到。
1、这两个语句离开应用范围，存在是没有意义的。
2、这个两个语句单独存在，下面都不可以有语句，因为执行不到。
1.2.3标号
标号的出现，可以让这两个语句作用于指定的范围。
示例1：
/**
* @author jinlong
* */
package com.blog.part1;
public class BreakDemo1
{
public static void main(String[] args)
{
//添加标号。形式为 out：和in：
out:for(int x=0;x<3;x++)
{
in:for(int y=0;y<4;y++)
{
System.out.println("x="+x);
//这里可以用标号选择跳出的位置
break out;
//break in;
}
}
}
}
运行结果：
示例2
/**
* @author jinlong
* */
package com.blog.part1;
public class ContinueDemo
{
public static void main(String[] args)
{
out: for(int x = 0; x < 3; x++)
{
in: for(int y = 0; y < 4; y++)
{
System.out.println("x = " + x);
continue out ;
}
}
}
}
运行结果：
2. 函数
2.1 概述
2.1.1定义
函数就是定义在类中的具有特定功能的一段独立小程序，函数也称为方法。
{
执行语句;
return 返回值;
}
返回值类型：函数运行后的结果的数据类型。
参数类型 ：是形式参数的数据类型。
形式参数 ：是一个变量，用于存储调用函数时传递给函数的实际参数。
实际参数 ：传递给形式参数的具体数值。
return ：用于结束函数。
返回值 ：该函数运算后的结果，该结果会返回给调用者。
2.1.2格式
修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，...){
执行语句;
return 返回值;
}
返回值类型：函数运行后的结果的数据类型。
参数类型 ：是形式参数的数据类型。
形式参数 ：是一个变量，用于存储调用函数时传递给函数的实际参数。
实际参数 ：传递给形式参数的具体数值。
return ：用于结束函数。
返回值 ：该函数运算后的结果，该结果会返回给调用者。
示例1
/**
* @author jinlong
* */
package com.blog.part1.函数;
public class FunctionDemo
{
public static void main(String[] args)
{
//函数名直接调用
sop("打印函数");
}
//这里将打印语句再次封装成一个函数sop
public static void sop(Object obj)
{
System.out.println(obj);
}
}
运行结果：
2.1 函数的特点
1、定义函数可以将功能代码进行封装，便于对该功能进行复用。
2、函数只有被调用才会被执行。
3、函数的出现提高了代码的复用性。
注意：.
1、对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后
1、定义函数可以将功能代码进行封装，便于对该功能进行复用。
2、函数只有被调用才会被执行。
3、函数的出现提高了代码的复用性。
注意：.
1、对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后
一行可以省略不写，或者写上return;。
2、函数中只能调用函数，不可以在函数内部定义函数。否则，编译时期就会报错
。
3、函数结果应该交给函数调用者来处理
2.3 函数的应用
明确在定义该功能的过程中，是否需要未知内容参与运算。
示例1：
需求：定义一个功能，完成两个整数的和的获取。
思路：既然定义功能，就可以用函数来体现。
通过两个明确来完成：
明确一：这个功能的结果是什么？是和。是功能的结果，所以该功能的返回值类型是int。其实，就是在明确函数的返回值类型。
明确二：这个功能实现过程中是否需要未知内容参与运算？有，加数和被加数。这就是函数的参数列表（参数的个数，参数的类型）。
明确一：这个功能的结果是什么？是和。是功能的结果，所以该功能的返回值类型是int。其实，就是在明确函数的返回值类型。
明确二：这个功能实现过程中是否需要未知内容参与运算？有，加数和被加数。这就是函数的参数列表（参数的个数，参数的类型）。
其实，就是在明确参数列表。
PS.返回值类型只看函数中定义，和参数类型没有关系。
代码：
PS.返回值类型只看函数中定义，和参数类型没有关系。
代码：
public static int add(int a,int b)
{
return a + b;
}
示例2：
需求：定义一个功能，画一个矩形在控制台。
思路：既然定义功能，就可以用函数来体现。
明确一：这个功能结果是什么？没有结果，因为直接打印到了控制台，并未返回给调用者。用void表示。
明确二：这个功能实现过程中是否需要未知内容参与运算？有，行和列不确定，两个，整数int类型。
代码：
public static void draw(int row,int col)
{
for(int x = 1; x <= row; x++)
{
for(int y = 1; y <= col; y++)
{
System.out.print("*");
}
System.out.println();
}
return;//可以省略不写
}
示例3：
需求：两个数是否相等。
明确一：这个功能的结果是什么？有，boolean类型。
明确二：这个功能实现过程中是否需要未知内容参与运算？有，两个整数。
代码：
public static boolean equals(int a,int b)
{
return a == b;
}
示例4：
需求：定义一个功能，获取两个整数中较大的那个数。
明确一：这个功能的结果是什么？有，是int类型。
明确二：这个功能实现过程中是否需要未知内容参与运算？有，参与比较的两个整数，int类型。
代码：
示例5：
定义功能，打印99乘法表。
代码：
public static void print99()
{
for(int x = 1; x <= 9; x++)
{
for(int y = 1; y <= x; y++)
{
System.out.println(y + "*" + x + "=" + y*x + "\t");
}
}
}
示例6：
根据考试成绩获取学生分数对应的等级。
90~100 A
80~89 B
70~79 C
60~69 D
60以下 E
代码：
public static char getLevel(int num)
{
//定义等级为level
char level;
//用if语句做判断
if(num >= 90 && num <= 100)
level = 'A';
else if(num >= 80 && num <= 89)
level = 'B';
else if(num >= 70 && num <= 79)
level = 'C';
else if(num >= 60 && num <= 69)
level = 'D';
else
level = 'E';
//返回char类型的level值。
return level;
}
2.3 函数的重载
2.3.1概述
重载的概念：
在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
重载的好处：
方便于阅读，优化了程序设计。
示例：
在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
重载的好处：
方便于阅读，优化了程序设计。
示例：
/**
* 需求：演示函数重载
* @author jinlong
* */
package com.blog.part1.函数;
public class FuncOverrideDemo {
public static void main(String[] args)
{
//调用sum函数，根据不同的传入参数，系统会自动选择加载哪个sum
sop(sum(1,2));
sop(sum(1.5,2.5));
sop(sum(1.5,2.5,1.5));
}
//定义参数为（int a,int b）的函数sum
public static int sum(int a,int b)
{
return a+b;
}
//定义参数为（double a,double b）类型的函数sum
public static double sum(double a,double b)
{
return a+b;
}
//定义三个参数的函数sum
public static double sum (double a,double b,double c)
{
return a+b+c;
}
//打印函数
public static void sop(Object obj)
{
System.out.println(obj);
}
}
运行结果：
总结：
函数的功能一样，仅仅是参与运算的未知内容不同时，可以定义多函数，却使用统一函数名称，这样方便阅读。在调用时，虚拟机通过参数列表 的不同来区分同名函数。
重载与返回值类型无关，只看参数列表。
3. 数组
3.1 数组的定义
2.3.1概述
定义：同一种类型数据的集合。其实，数组就是一个容器。
数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。
2.3.2格式
格式1:不明确具体数据时元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
格式2：需要一个容器，存储已知的具体数据。
元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
示例：
或
元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
示例：
或
3.2 数组的内存分配及特点
Java程序在运行时，需要在内存中分配空间。为了提高运算效率，又对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内 存管理方式。
示例：
int[] arr = new int[4];
内存分配图：
栈内存：
用于存储局部变量，当变量所属的作用域一旦结束，所占空间会自动释放。
堆内存：
数组和对象，通过new建立的实例都存放在堆内存中。每一个实体都有内存地址值。
实体中的变量都有默认初始化值，根据类型的不同而不同。整数类型是0，小数类型是0.0或0.0f，boolean类型是false，char类型是'\u0000'。
如果将数组的引用实体设置为null，也就是实体不再被使用，那么会在不确定的时间内被垃圾回收器回收。
int[] arr = new int[4];
内存分配图：
栈内存：
用于存储局部变量，当变量所属的作用域一旦结束，所占空间会自动释放。
堆内存：
数组和对象，通过new建立的实例都存放在堆内存中。每一个实体都有内存地址值。
实体中的变量都有默认初始化值，根据类型的不同而不同。整数类型是0，小数类型是0.0或0.0f，boolean类型是false，char类型是'\u0000'。
如果将数组的引用实体设置为null，也就是实体不再被使用，那么会在不确定的时间内被垃圾回收器回收。
3.3 数组操作常见问题
3.3.1数组脚标越界异常
ArrayIndexOutOfBoundsException ：访问到了数组中的不存在的脚标时发生。
示例1：
示例1：
class ArrayDemo
{
public static void main(String[] args)
{
int[] arr = new int[3];
System. out.println(arr[3]);
}
}
3.3.2 空指针异常
NullPointerException：当引用型变量没有指向任何实体时，用其操作实体，就会发生该异常。
示例2：
/** * 需求：数组越界异常展示 * @author jinlong * */ package com.blog.part1.数组; class ArrayDemo
{
public static void main(String[] args)
{
int[] arr = null;
System. out.println(arr[0]);
}
}
示例3：
直接打印数组的引用变量，打印出来的结果是数组初始地址的哈希值。
"[I"表示的是int类型数组，"@"后面的3929df79内容表示数组初始地址的哈希值。