黑马程序员_Java编程基础下-CSDN博客

本文链接：https://blog.csdn.net/faithtang/article/details/7314205

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

程序流程控制：判断结构，选择结构，循环结构。

判断结构：

if语句三种格式：1. if(条件表达式)

{ 执行语句；

}

2. if(条件表达式)

{ 执行语句；

}

else

{ 执行语句；

}

3. if(条件表达式)

{ 执行语句；

}

else if(条件表达式)

{ 执行语句；

}

else

{ 执行语句；

}

注：if else结构简写格式：变量=（条件表达式）？表达式1：表达式2；（三元运算符）

优点：可以简化if else代码。

缺点：因为是一个运算符，所以运算完必须要有一个结果。而if else结构运算完，可以不需要有结果。

选择结构：

switch语句格式： switch(表达式)

{ case 取值1:

执行语句;

break;

case 取值2:

执行语句;

break;

.......

default:

执行语句;

break;

}

switch语句特点：

1.switch语句选择的类型只有四种：byte,short,int,char。

2.case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。

3.结束switch语句的两种情况：遇到break；执行到switch语句结束。

4.如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。

if和switch语句的应用：

如果判断的具体数值不多，且符合byte,short,int,char这四种类型，虽然两个语句都可以使用，建议使用switch语句。因为效率更高。

对区间判断，对结果为boolean类型判断，使用if语句。if的使用范围更广。

循环结构：

代表语句：while,do while,for

while语句的格式： while(条件表达式)

{ 执行语句(循环体);

}

do while语句格式： do

{ 执行语句；

}

while(条件表达式);

do while语句的特点：无论条件是否满足，循环体至少被执行一次。

区别：

while语句：先判断条件，只有条件满足才执行循环体。

do while语句：先执行循环体，再判断条件，条件满足，再继续执行循环体。

for语句格式： for(初始化表达式；循环条件表达式；循环后的操作表达式)

{ 执行语句；

}

注：

1.for语句里面的连个表达式运行的顺序：初始化表达式只读一次，判断循环条件为true就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复这个过程，直到条件不满足为止。

2.while语句与for语句可以互换。区别在于for为了循环而定义的变量在for循环结束就在内存中释放，而while循环使用的变量在循环结束后还可继续使用。

3.最简单无限循环格式：while(true){}，for( ; ; ){}，无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。

循环结构的应用：当要对某些语句执行很多次时，就使用循环结构。例如

累加思想：通过变量记录住每次变化的结果。通过循环的形式，进行累加动作。

计数器思想：通过一个变量记录住数据的状态变化。也需通过循环完成。

其他流程控制语句

break语句：应用于选择结构和循环结构。

continue语句：应用于循环结构。

注意：

1.这两个语句离开应用范围，存在是没有意义的。

2.这两个语句单独存在，下面都不可以有语句，因为执行不到。

3.continue语句是结束本次循环，继续下一次循环。

4.标号的出现，可以让这两个语句作用于指定的范围。

例：

w:for(int x=0;x<3;x++)
{
q:for(int y=0;y<5;y++)
{
System.out.println("x="+x);
break q;//跳出q循环
}
}

w:for(int x=0;x<3;x++)
{
q:for(int y=0;y<5;y++)
{
System.out.println("x="+x);
continue w;//结束内循环，继续外循环w
}
}

w,q：叫做循环结构标号。

函数：函数的定义，函数的特点，函数的应用，函数的重载。

函数的定义：函数就是定义在类中的具有特定功能的一段独立小程序。函数也称为方法。

函数的格式：

修饰符返回值类型函数名（参数类型形式参数1，参数类型形式参数2，····）

{

执行语句；

return 返回值；

}

返回值类型：函数运行后的结果的数据类型。

参数类型：是形式参数的数据类型。

形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。

实际参数：传递给形式参数的具体数值。

return：用于结束函数。

返回值：该值会返回给调用者。

注：Java中对功能的定义是通过函数的形式来体现的。

函数的特点：

1.定义函数可以将功能代码进行封装。

2.便于对该功能进行复用。

3.函数只有被调用才会被执行。

4.函数的出现提高了代码的复用性。

5.对于函数没有具体返回值的情况，返回值类型用关键字void表示（void：代表的是函数没有具体返回值的情况），那么该函数中的return语句如果在最后一行可以省略不写。

注意：函数中只能调用函数，不可以在函数内部定义函数。定义函数时，函数的结果应该返回给调用者，交由调用者处理。

函数的应用：

如何定义一个函数？

1.函数是一个独立的功能，先明确该功能运算结果是什么。

2.再明确定义该功能的过程中是否需要未知的内容参与运算。

函数的重载：

重载：在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。

重载的特点：与返回值类型无关，只看参数列表。

重载的好处：方便于阅读，优化了程序设计。

重载示例：

返回两个整数的和：int add(int x,int y){return x+y;}

返回三个整数的和：int add(int x,int y,int z){return x+y+z;}

返回两个小数的和：double add(double x,double y){return x+y;}

重载的应用：当定义的功能相同，但参与运算的未知内容不同。那么，这时就定义一个函数名称以表示其功能，方便阅读，而通过参数列表的不同来区分多个同名函数。

数组：数组的定义，数组的内存分配及特点，数组操作常见问题，数组常见操作，数组中的数组。

数组的定义：同一种类型数据的集合。其实数组就是一个容器。

数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。

数组的格式：

格式1：元素类型[] 数组名=new 元素类型[元素个数或数组长度];

示例： int[] arr=new int[5]; 也可以写成：int arr[]=new int[5];

格式2：元素类型[] 数组名=new 元素类型[]{元素,元素,·····}

示例： int[] arr=new int[]{3,5,7,2,1};

int[] arr={3,5,43,2};

内存结构：

Java程序在运行时，需要在内存中分配空间。为了提高运算效率，又对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。

堆内存：数组和对象，通过new建立的实例都存放在堆内存中。每一个实体都有内存地址值。实体中的变量都有默认初始化值。实体不再被使用，会在不确定的时间内被垃圾回收器回收。

数组的操作：

获取数组中的元素，通常会用到遍历（循环）。例如：

int[] arr=new int[3];
  for(int x=0;x<3;x++)
  {
   System.out.println("arr["+x+"]="+arr[x]);
  }

数组中有一个属性可以直接获取到数组元素个数。使用方式：数组名称.length=

1.求数组中所有元素的和。

代码：

int[] arr={2,5,4,8,1,6,76,9,29};
int sum=0;
for(int x=0;x<arr.length;x++)
{
sum+=arr[x];
}
System.out.println("sum="+sum);

2.获取一个数组中的最大值和最小值。

获取最大值：

public static int getMax(int[] arr)
{
int max=0;
for(int x=1;x<arr.length;x++)
{
  if(arr[x]>arr[max])
  {
   max=x;
  }
}
return arr[max];
}

获取最小值：

public static int getMin(int[] arr)
{
int min=0;
for(int x=1;x<arr.length;x++)
{
  if(arr[x]<arr[min])
  {
   min=x;
  }
}
return arr[min];
}

3.对数组进行排序。

选择排序：内循环结束一次，最值出现在头角标位置上。代码：

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 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;
   }
  }
}
}

3.数组的查找操作：

定义功能，获取key第一次出现在数组中的位置。如果返回是-1，那么代表该key在数组中不存在。代码：

public static int getIndex(int[] arr,int key)
{
for(int x=0;x<arr.length;x++)
{
if(arr[x]==arr[key])
return x;
}
return -1;
}

注：如果该数组是有序的数组，可折半查找，提高效率。代码：

public static int halfSearch(int[] arr,int key)
{
int min=0,max=arr.length-1,mid;
while(min<=max)
{
  mid=(max+min)>>1;
  if(key>arr[mid])
   min=mid+1;
  else if(key<arr[mid])
   max=mid-1;
  else
   return mid;
}
return -1;
}

4.用查表法求进制转换。

查表法：将所有的元素临时存储起来，建立对应关系。每一次&后的值作为索引去查建立好的表，就可以找到对应的元素。

定义的进制转换功能：

public static void trans(int num,int base,int offset)
{
if(num==0)
{
  System.out.println(0);
  return;
}
char[] chs={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char[] arr=new char[32];
int pos=arr.length;
while(num!=0)
{
  int temp=num&base;
  arr[--pos]=chs[temp];
  num=num>>>offset;
}
for(int x=pose;x<arr.length;x++)
{
  System.out.print(arr[x]);
}
}