------- android培训、java培训、期待与您交流！ ----------
判断结构：
判断语句：
格式一
If(条件表达式)
{
执行语句；
}
格式二
If(条件表达式)
{
执行语句;
}
else
{
执行语句;
}
If格式二:多了一个else语句块。如果...否则...意味着，这两个语句块肯定有一个执行。
三元运算符：就是if else 语句的简写格式。
只有当if else语句执行完有具体结果时，才可以简写成三元运算符的形式。因为三元运算符是一个运算符，只要是运算符运算完必须有结果。
If只有单条语句的时候可以省略大括号
单条语句：一个完整的整体才是一条单条语句。
格式三
if(条件表达式)
{
执行语句;
}
else if(条件表达式)
{
执行语句;
}
... ...
else
{
执行语句;
}
特点:
1.虽然有多行，但是是单条语句。
2.虽然有多个代码块组成，但是只有一个会执行。
3.对语句进行多次判断。
选择语句：
switch（表达式） 表达式只接收四种类型的值 byte short int char
{
case 取值1： case的书写是没有顺序的，从具体答案先执行，最后
执行语句； 执行default。
break；
case 取值2：
执行语句；
break；
default：
执行语句；
}
结束switch语句有两种情况：遇到break或执行到switch语句大括号结束。
如果匹配的case或default没有break，那么程序会一直执行到结束。
当值不多，且符合byte short int char，用switch较高效
当结果为boolean型或区间的情况用if
例如：
public class SwitchDemo{
public static void main(String[] args) {
int x=3;
switch (x)
{
default:
System.out.println(3);
case 1:
System.out.println(4);
break;
case 2:
System.out.println(5);
}
}
}
运行结果：3 4
循环结构：
代表语句：while do while for
While语句格式：
While(条件表达式)
{
执行语句;
}
Do while语句格式
Do
{
执行语句；
}
While(条件表达式);
While条件不满足，循环体不会执行。
Do while无论条件是否满足，循环体至少执行一次。
循环结构的使用：
当某些语句需要执行很多次，这时就必须要想到循环结构
For循环结构
格式：
For(初始化表达式；循环条件表达式；循环后的操作表达式)
{
执行语句;(循环体)；
}
For循环和while循环的区别：
变量除了需要定义才能使用外还有一个作用域的问题，如for循环语句，变量x在循环语句中有效，循环结束则消失。
While循环结束，变量仍存在。
For(int x = 1，y = 1；x<3；x++，y++)
For循环可以定义多个变量，和多个循环后的表达式。
For( ； ；)//for语句的最简单的无限循环模式。条件表达式不写，默认情况下为ture
While(ture)//while语句的最简单无限循环格式。
练习
1 获取1到10的和，并打印。（累加思想）
class Demo
{
public static void main(String[] args)
{
int sum =0;
for(int x=1;x<=10;x++)
{
sum = sum + x;
}
System.out.println("sum="+sum);
//一定要明确哪些需要循环，哪些不需要
}
}
2 获取1～100之间7的倍数的个数，并打印（计数器思想）
class Demo
{
public static void main(String[] args)
{
int count = 0;
for(int x = 1;x<=100;x++)
{
if (x%7==0)
/*=和==的区别：一个等号是赋值号，两个等号是判断号。赋值表示把右边的值或引用赋给左边的变量，判断号表示返回符号两边的值是否相等，这里的值包括引用。*/
count++;
}
System.out.println("count="+count);
}
}
3000米长绳子，每天减一半。需要多少天绳子小于五米？
class Demo
{
public static void main(String[] args)
{
int count = 0;
for(int x = 3000;x>=5;x=x/2)
{
count++;
}
System.out.println("count="+count);
}
}
For循环的嵌套循环
利用循环嵌套输出各种图形：
1.需求：输出下列图形（尖朝下）
*****
****
***
**
*
class Demo
{
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.需求：打印出下列图形（尖朝上）
1
12
123
1234
12345
class Demo
{
public static void main(String[] args)
{
for (int x=1;x<=5;x++ )
{
for (int y=1;y<=x ;y++ )
{
System.out.print(y);
}
System.out.println();
}
}
}3.需求：打印出九九乘法表（尖朝上）
思路：观察乘法表，发现*两边的数有规律，正符合循环嵌套，并且定义好循环变量的值。
public class ChengFaBiao {
public static void main(String[] args) {
for(int x=1;x<=9;x++)
{
for(int y=1;y<=x;y++)
{
System.out.print(y+"*"+x+"="+y*x+"\t");
//加上\t是制表位，目的是让打印出来的数据较为整齐
}
System.out.println();
}
}
}
打印结果：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
..................
1.尖朝上，要让内层的循环条件随着外层循环变化。
2.尖朝下，要让内层的初始化值随着外层循环变化
break和continue
1.作用范围
break作用在switch和循环结构内
continue只作用在循环结构内
标号只能用于循环上，给循环起名字的一种方式，可以让这两个语句作用于指定的范围。
2.意义
break指跳出其所在的循环
continue指跳出本次循环继续执行下次循环
3.break和continue单独存在时下面不可以有语句，因为都执行不到。
For(int x =0;x<3;x++)
{
System.out.println(“*”)
break;//x=0,打印一次*，break跳出当前循环，循环结束
}
标号使用
class Demo
{
public static void main(String[] args)
{
w:for (int x = 0;x<3; x++)
{
p:for (int y = 0;y<4; y++)
{
System.out.println("x="+x);
break w;
}
}
}
}
求100~500之间所有不能被3、5、7、11和13同时整除的整数的和。class Demo
{
public static void main(String[] args)
{
int sum =0;
for (int x = 100;x<=500; x++)
{
if (x%3==0&x%5==0&x%7==0&x%11==0&x%13==0)
continue;
sum = x+sum;
}
System.out.println("sum="+sum);
}
}
需求：打印图形
*
* *
* * *
* * * *
分析：可以将其看成是两个图形的组合，补的都是空格，
一个for循环里，嵌入两个for
class Demo
{
public static void main(String[] args)
{
for (int x =0;x<5 ;x++ )
{
for (int y =x;y<5 ;y++ )
{
System.out.print(" ");
}
for (int z =0;z<x ;z++ )
{
System.out.print("* ");
}
System.out.println();
}
}
}
函数
一.函数的定义
函数就是定义在类中的具有特定功能的一段独立小程序。也称为方法。
函数的格式：
修饰符返回值类型函数名(参数类型形式参数1，参数类型形式参数2，)
{
执行语句;
return 返回值;
}
函数的特点：
1定义函数可以将功能代码进行封装
2便于对该功能进行复用
3函数只有被调用才会被执行
4函数的出现提高了代码的复用性
5对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后 一行可以省略不写。
注意：
1函数中只能调用函数，不可以在函数内部定义函数。
2定义函数时，函数的结果应该返回给调用者，交由调用者处理。
两个明确
1明确要定义的功能最后的结果是什么？
2明确在定义该功能的过程中，是否需要未知内容参与运算
函数的重载（overload）
什么时候用重载？
当定义的功能相同时，但参与运算的未知内容不同，此时就定义一个函数名称表示其功能，
方便阅读，而通过参数列表的不同来区分不同函数。
重载的特点：与返回值类型无关，只看参数列表，参数列表是有顺序之分的。
重载的好处：方便阅读，优化了程序设计
定义一个功能，用于打印矩形
class Demo
{
public static void main(String[] args)
{
getJu(3,4);
}
public static void getJu(int row,int col)
{
for (int x =0;x<row ;x++ )
{
for (int y =0;y<col ;y++ )
{
System.out.print("*");
}
System.out.println();
}
}
}
定义一个打印九九乘法表的功能。
class Demo
{
public static void main(String[] args)
{
get99(7);
}
public static void get99(int num)
{
for (int x =1;x<=num ;x++ )
{
for (int y =1;y<=x ;y++ )
{
System.out.print(x+"*"+y+"="+x*y+"\t");
}
System.out.println();
}
}
}
数组
数组的定义
同一种类型数据的集合。其实数组就是一个容器。
优点：可以自动给数组中的元素从0开始编号，方便操作这些元素。
格式1：
元素类型[] 数组名 ＝ new 元素类型[元素个数或数组长度]；
如：int[] arr=new int[5];
格式2：
元素类型[] 数组名 ＝ new 元素类型[]{元素，元素，元素。。。}；
如：int[] arr=new int[]{2,4,2,6,21};
int[] arr={2,4,2,6,21};
数组内存结构：java程序在运行时，需要在内存中分配空间。为了提高运算效率，对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。堆内存：数组和对象，通过new建立的实例都存放在堆内存中；每一个实体都有内存地址值；实体中的变量都有默认初始化值；实体不在被使用，会在不确定的时间内被垃圾回收器回收。
数组常见的两种错误
1.ArryIndexOutOfBoundsException:说明的角标超过了数组的长度。
2.NullPointerException：说明没有任何引用指向数组，不能对数组进行操作。
以上两种错误，编译都能通过，运行时产生错误。
数组名.length，就可获取数组的长度值。
二维数组
二维数组[][]：数组中又定义了数组。
格式1：int[][] arr = new int[3][2];定义了名为arr的二维数组，二维数组中有三个一位数组，每一个一位数组中有两个元素，一维数组的名称分别为arr[0], arr[1], arr[2]。
格式2：int[][] arr = new int[3][];二维数组中有3个一维数组，每个一维数组都是默认初始化值null。
格式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}}; 定义一个名称为arr的二维组，二维数组中的有三个一维数组，每一个一维数组中具体元素也都已初始化。
求数组的最值
class Demo
{
public static void main(String[] args)
{
int[] arr = {3,18,2,4,7};
getMax(arr);
}
public static void getMax(int[] arr)
{
int max = arr[0];
for (int x =0;x<arr.length ;x++ )
{
if(max<arr[x])
{
max=arr[x];
}
}
System.out.println(max);
}
}
选择排序
class Demo
{
public static void main(String[] args)
{
int[] arr =new int[]{2,5,4,7,9,1};
printArray(arr);
selectSort(arr);
printArray(arr);
}
public static void selectSort(int[] arr)
{
for (int x =0;x<arr.length-1 ;x++ )
{
for (int y =x+1;y<arr.length ;y++ )
{
if (arr[x]>arr[y])
{
int temp =arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
}
}
}
public static void printArray(int[] arr)
{
System.out.print("[");
for (int x =0;x<arr.length ;x++ )
{
if (x!=arr.length-1)
{
System.out.print(arr[x]+",");
}
else
System.out.println(arr[x]+"]");
}
}
}
冒泡排序
class Demo
{
public static void main(String[] args)
{
int[] arr =new int[]{2,5,4,7,9,1};
printArray(arr);
bubbleSort(arr);
printArray(arr);
}
public static void printArray(int[] arr)
{
System.out.print("[");
for (int x =0;x<arr.length ;x++ )
{
if (x!=arr.length-1)
{
System.out.print(arr[x]+",");
}
else
System.out.println(arr[x]+"]");
}
}
public static void bubbleSort(int[] arr)
{
for (int x =0;x<arr.length-1 ;x++ )
{
for (int y =0;y<arr.length-x-1 ;y++)
{
if(arr[y]<arr[y+1])
{
int temp =arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;
}
}
}
}
}
总结选择排序与冒泡排序
一个是拿一个元素与其它所有元素比较，外循环与内循环比较换位。
一个是相邻两个元素比较，外循环控制次数，内循环为两个元素比较再。换位
位置转换功能抽取
public static void bubbleSort(int[] arr)
{
for (int x =0;x<arr.length-1 ;x++ )
{
for (int y =0;y<arr.length-x-1 ;y++)
{
swap(arr,y,y+1);
}
}
}
public static void swap(int[] arr,int a,int b)
{
int temp= arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
}
数组的查找操作
class Demo
{
public static void main(String[] args)
{
int[] arr =new int[]{2,5,4,7,9,1};
int index=getIndex(arr,4);
System.out.println("index="+index);
}
public static int getIndex(int[] arr,int key)
{
for (int x =0;x<arr.length ;x++ )
{
if (arr[x]==key)
{
return x;
}
}
return -1;
}
}
折半查找
public class ZheBan
{
public static void main(String[] args)
{
int[] arr={1,5,7,9};
int index=chaZhao(arr,8);
System.out.println("index="+index);
}
public static int chaZhao(int[] arr,int key)
{
//这些都是角标值
int min=0;
int max=arr.length-1;
int mid=(min+max)/2;
//进行while循环判断
while(key!=arr[mid])
{
if(key>arr[mid])
min=mid+1;
else if(key<arr[mid])
max=mid-1;
if(min>max)
return mid; //插入。 如果不存在可以返回-1.
mid=(min+max)/2;
}
return mid;
}
}
另一种方法
与第一种方式区别在于控制循环的条件变了。
public class ZheBan2 {
public static void main(String[] args) {
int[] arr={1,5,7,9};
int index=chaZhao(arr,7);
System.out.println("index="+index);
}
public static int chaZhao(int[] arr,int key)
{
int min=0,max=arr.length,mid;
while(min<=max)
{
mid=(min+max)/2;
if(key>arr[mid])
min=mid+1;
else if(key<arr[mid])
max=mid-1;
else
return mid;
}
return -1;
}
}
练习：在有序数组中插入一个数，保证数组任然有序。
方法：
1.如果数组中有要插入的这个数，那么通过折半查找，找出这个数的位置就是要插入的位置。
2.如果数组中没有要插入的这个数，则返回折半操作后的最小角标值（min）就是要插入的位置。
class Demo
{
public static void main(String[] args)
{
int[] arr={1,5,7,9};
int index = getIndex(arr,8);
System.out.println("index="+index);
}
public static int getIndex(int[] arr,int key)
{
int max=arr.length-1,min=0,mid=(max+min)/2;
while(min<=max)
{
if (key>arr[mid])
min=mid+1;
else if (key<arr[mid])
max=mid-1;
else
return mid;
mid=(min+max)/2;
}
return min;
}
}
总结：
无序数组排序：选择排序与冒泡排序
有序数组查找角标值：遍历查找，折半查找
十进制转二进制
class Demo
{
public static void main(String[] args)
{
toBin(6);
}
public static void toBin(int num)
{
StringBuffer sb = new StringBuffer();//创建对象，用于存储数据
while (num>0)
{
sb.append(num%2);//append意为添加
//System.out.println(num%2);
num=num/2;
}
System.out.println(sb.reverse());//reverse意为反转数据
}
}
十进制转十六进制
class Demo
{
public static void main(String[] args)
{
toHex(60);
}
public static void toHex(int num)
{
for (int x =0;x<8 ;x++ )
{
int temp=num&15;
if (temp>9)
{
System.out.println((char)(temp-10+'A'));
}
else
System.out.println(temp);
num=num>>>4;
}
}
}
class Demo
{
public static void main(String[] args)
{
toHex(60);
}
public static void toHex(int num)
{
StringBuffer sb = new StringBuffer();//创建对象，用于存储数据
for (int x =0;x<8 ;x++ )
{
int temp=num&15;
if (temp>9)
{
sb.append((char)(temp-10+'A'));//强制转换类型
}
else
sb.append(temp);
num=num>>>4;
}
System.out.println(sb.reverse());//reverse意为反转数据
}
}
扫一扫
1368
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
