2 Java语言基础组成

Java语言基础组成：

关键字：就是被Java赋予了特殊含义的单词 

  标识符 ：在程序中自定义的一些名称（数字不可以开头 不可以使用关键字）

 注释：用于注解说明解释程序的文字就是注释。（单行注释、多行注释、文档注释 ）

 常量和变量：常量  ：常量表示不能改变的值。整数进制：二进制    八进制    十进制    十六进制   进制的转换  十进制转二进制：十进制进行除2运算  二进制转十进制 ：二进制进行乘2运算。

变量：内存中的一个存储区域，将不确定的数据进行存储。什么时候定义变量？只要是数据不确定的时候，就定义变量。

运算符  ：1）、算术运算符。  + - * / %   %   +:连接符。   ++,--  2）、赋值运算符。 =  += -= *= /= %=  3）、比较运算符。   特点：该运算符的特点是：运算完的结果，要么是true，要么是false。   4）、逻辑运算符。 
  &  |  ^  !   &&   ||  逻辑运算符除了 !  外都是用于连接两个boolean类型表达式。   &: 只有两边都为true结果是true。否则就是false。   |:只要两边都为false结果是false，否则就是true   ^:异或：和或有点不一样。 
    两边结果一样，就为false。     两边结果不一样，就为true.        & 和 &&区别： & ：无论左边结果是什么，右边都参与运算。      &&:短路与，如果左边为false，那么右边不参数与运算。   | 和|| 区别：|：两边都运算。 
     ||：短路或，如果左边为true，那么右边不参与运算。  5）、位运算符:用于操作二进制位的运算符。

语句 ：1.选择结构 
1.if语句    
A. 格式: if(条件表达式){ 
语句组 } 
B. 语法: 满足条件表达式，执行语句组
2.if-else语句 
A. 格式:if(条件表达式){ 
语句组1 }

else{ 
语句组2 } 
B. 语法: 满足条件表达式，执行语句组1，否则执行语句组2 } 
3.if-else-if语句 
A. 格式:if(条件表达式1){ 
语句组1 
}

else if(条件表达式1){ 
语句组2 

}

else{ 

语句组3 } 
B. 语法: 满足条件表达式1，执行语句组1，否则查看是否满足条件表达式2，如果满足，执行语句组2，否则执行语句组3

4.switch语句 
A. 格式:switch(表达式){       //表达式只能是byte，short，int，char类型的数据 
case 常量1:  表达式1;  break;

case 常量2:  表达式2;  break;

case 常量3:  表达式3;  break;

default : 表达式4  } 
B. 语法:拿表达式的值和常量的值相比较，如果相同，则执行对应的表达式，如果都不相同，则执行default后面的表达式

2.循环结构 
1.while语句 
A. 格式: while(布尔表达式){ 
语句组 } 
B. 语法: 布尔表达式为真，则执行语句组

2.do-while语句 
A. 格式: do{ 
语句组 
}

while(布尔表达式); 
B. 语法: 先执行语句组，再判断布尔表达式，如果布尔表达式为真，则继续执行语句组，否则，结束循环语句

3.for语句 
A. 格式: for（初始化表达式;条件表达式;迭代语句）{ 
语句组 
     } 
B. 语法: 先执行初始化表达式，再判断条件表达式是否为真，如果为真，执行语句组，然后执行迭代语句，然后再执行条件表达式，直到条件表达式为假跳出循环。

 break跳出循环体，continue跳出本次循环进入下次循环。

  函数  ：为了提高代码的复用性，可以将其定义成一个单独的功能，该功能的体现就是java中的函数。函数就是体现之一。

 java中的函数的定义格式：  修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数1，„){   执行语句；   return 返回值；  } 当函数没有具体的返回值时，返回的返回值类型用void关键字表示。 
如果函数的返回值类型是void时，return语句可以省略不写的，系统会帮你自动加上。 return的作用：结束函数。结束功能。  
如何定义一个函数？ 
 函数其实就是一个功能，定义函数就是实现功能，通过两个明确来完成：  1）、明确该功能的运算完的结果，其实是在明确这个函数的返回值类型。  2）、在实现该功能的过程中是否有未知内容参与了运算，其实就是在明确这个函数的参数 列表(参数类型&参数个数)。

 函数的作用： 1）、用于定义功能。 2）、用于封装代码提高代码的复用性。 注意：函数中只能调用函数，不能定义函数。 主函数：  1）、保证该类的独立运行。  2）、因为它是程序的入口。  3）、因为它在被jvm调用。

重载的定义是：在一个类中，如果出现了两个或者两个以上的同名函数，只要它们的参数的个数，或者参数的类型不同，即可称之为该函数重载了。 
如何区分重载：当函数同名时，只看参数列表。和返回值类型没关系

数组：用于存储同一类型数据的一个容器。好处：可以对该容器中的数据进行编号，从0开始。数组用于封装数据，就是一个具体的实体。 
如何在java中表现一个数组呢？两种表现形式。 1）、元素类型【】 变量名 = new 元素类型【元素的个数】； 2）、元素类型【】 变量名 = {元素1，元素2...}； 元素类型【】变量名 = new 元素类型【】{元素1，元素2...}；

程序举例

1 循环语句

class  sanjiao
{
public static void main(String[] args) 
{
for (int x=0;x<5;x++ )
{
for (int y=x+1;y<5;y++ )
{
System.out.print(" ");
}
for (int z=0;z<=x;z++ )
{
System.out.print("* ");
}
System.out.println();
}

}
}

2 综合小程序

class Function 
{
public static void main(String[] args) 
{
int x=getResult(4);
System.out.println("x="+x);
Get(4);
int y=getSum();
System.out.println("y="+y);
int sum=Sum(4,6);
System.out.println("sum="+sum);
boolean b=compare(3,4);
System.out.println("b="+b);
int a=getMax(3,9);
System.out.println("a="+a);
draw(3,5);
printHr();
draw(4,7);
printHr();
draw(5,3);
printHr();
print99();
}


//一个数乘以3加5
public static int getResult (int num)
{
return num*3+5;
}


public static void Get (int sum)
{
System.out.println(sum*3+5);
}
    //两个数求和
public static int getSum ()
{
return 3+4;
}


public static int Sum (int x,int y)
{
return x+y;
}


//比较两个数大小
public static  boolean compare (int a,int b)
{
/*if (a==b)
return true;
else
return false;*/


return (a==b)?true:false;
//return a==b;
}


//比较两个数大小取最大值
public static int getMax (int a,int b)
{
if(a>b)
return a;
else 
return b;
//return (a>b)?a:b;
}


//打印矩形
public static void draw (int a,int b)
{
for(int x=0;x<a;x++)


{
for(int y=0;y<b;y++)
System.out.print("*");
System.out.println();
}
}
public static void printHr ()
{
System.out.println("-----------------------");
}


//打印 99乘法表 
public static void print99 ()
{


for (int x=1;x<=9 ;x++ )
{
for (int y=1;y<=x ;y++ )
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}

}
}

3 进制转换

class  jinzhi
{
public static void main(String[] args) 
{
//System.out.println(" ");
tobin(6);
tohex(60);
}
//十进制转换为十六进制
public static void tohex(int num)
{
/*int n1=num&15;
n1-10+'a'
int temp=num>>>4;
temp&15;*/
//StringBuffer sb=new StringBuffer();
for (int x=0;x<8 ;x++ )
{
int temp=num&15;
if(temp>9)
  System.out.println((char)(temp-10+'A'));
//sb.append((char)(temp-10+'A'));
else 
                System.out.println(temp);
 //  sb.append(temp);
num=num>>>4;
}
//System.out.println(sb.reverse());
}
/*
十进制转换为二进制
*/
public static void tobin(int num)
{
StringBuffer sb=new StringBuffer();
while(num>0)
{
//System.out.println(num%2);


sb.append(num%2);
num=num/2;
}
System.out.println(sb.reverse());
}


}

class  shuzu3
{
public static void main(String[] args) 
{
//tohex(60);
//toBin(-6);
tobin1(6);
to8(17);
tohex1(60);
}
/*
0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F  
0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15
把十六进制元素存进表里面 &15的结果肯定在15之内  那结果直接与表对应
 就可以找到对应的元素 ：比-10+A简单  查表法
表 ：通过数组的形式来定义
出结果 但是是反着的  用已经学过的容器 数组来存储
*/
public static void tohex(int num)
{
//定义十六进制表
char[] chs={'0','1','2','3',
          '4','5','6','7',
                    '8','9','A','B',
       'C','D','E','F'};
//定义一个临时容器
char[] arr= new char[8];
int pos=arr.length;
while(num!=0)
//for (int x=0;x<8 ;x++ )
{
int temp=num & 15; 
System.out.println(chs[temp]);
arr[--pos]=chs[temp];
num=num>>>4;
}
System.out.println("pos="+pos);
//数据存储arr遍历
for (int x=pos;x<arr.length ;x++ )
{
System.out.print(arr[x]+",");
}
}
  /*  public static void toBin(int num)
{
//定义二进制表
char[] chs={'0','1'};
//定义一个临时容器
char[] arr= new char[32];
//定义一个操作数组的指针
int pos=arr.length;
while(num!=0)
{
int temp=num & 1; 
arr[--pos]=chs[temp];
num=num>>>1;
}
System.out.println("pos="+pos);
//数据存储arr遍历
for (int x=pos;x<arr.length ;x++ )
{
System.out.print(arr[x]);
}

}*/
//进制转换优化


//十进制转二进制


public static void tobin1(int num)
{
trans(num,1,1);
}
//十进制转八进制
public static void to8(int num)
{
trans(num,7,3);
}

//十进制转十六进制
public static void tohex1(int num)
{
trans(num,15,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=pos;x<arr.length ;x++ )
{
System.out.println(arr[x]);
}
}


}


4       排序

class shuzu1 
{
public static void main(String[] args) 
{
int[] arr={4,5,6,3,1,2,7,9};
//排序前
printArray(arr);
//排序
//selectsort(arr);
bubblesort(arr);
//排序后
printArray(arr);


//Arrays.sort(arr);//java中已经定义好的一种排序方式，实际开发中对数组排序要使用这种方法
}
/*对数组进行排序 
选择排序： 内循环结束后  最值出现在头角标位置上
冒泡排序：最值出现在最后
嵌套循环
*/
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;*/
swap(arr,x,y);
}
}
}
}
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 ;x++ )
{
for (int y=0;y<arr.length-x-1 ;y++ )//-x让每一次比较的元素减少，-1避免角标越界
{
if (arr[y]>arr[y+1])
{
/*int temp=arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;
*/
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;
}


}
  5 获取

class shuzu2 
{
public static void main(String[] args) 
{
//int[] arr={3,2,1,6,4,9};
//int index=getIndex(arr,9);
//System.out.println("index="+index);
int[] arr={3,4,5,6,7,9};
 //  int index=halfsearch(arr,13);
// int index=halfsearch_2(arr,13);
//System.out.println("index="+index);
int index=getIndex_2(arr,2);
System.out.println("index="+index);


}
    /*折半查找 前提 数组是有序数组
      
*/
public static int halfsearch(int[] arr,int key)
{
int min,max,mid;
min=0;
max=arr.length-1;
mid=(max+min)/2;


while(arr[mid]!=key)
{
if(key>arr[mid])
min=mid+1;
else if(key<arr[mid])
max=mid-1;
if(min>max)
return -1;
mid=(max+min)/2;
}
return mid;
}
//折半的第二种方式
public static int halfsearch_2(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;
}




//定义功能 获取key第一次出现在数组中的位置 如果返回是-1，你们该key在数组中不存在
public static int getIndex(int[] arr,int key)
{
for (int x=0;x<arr.length ;x++ )
{
if(arr[x]==key)
return x;
}
return -1;
}
//有一个有序的数组，需要将一个元素插入到数组中 还要保证数组是有序的
//如何获取该元素在数组中的位置   换到最后min就是要的位置
public static int getIndex_2(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 min;
}
}

//二分查找法。必须有前提：数组中的元素要有序。  

6 获取最值

class  shuzu
{
public static void main(String[] args) 
{
int[] arr={5,2,5,5,6,7,8,9};
int max=getMax(arr);
System.out.println("max="+max);
int max1=getMax_2(arr);
System.out.println("max1="+max);
boolean[] ar =new boolean[3];
   System.out.println(ar[0]);
int min=getMin(arr);
System.out.println("min="+min);
double[] arr1=new double[]{3.2,5.6,7.8,9.8};
double max2=getMax(arr1);
   System.out.println("max2="+max2);
}
/*获取数组中最大最小值
获取最大值，比较，每一次比较都会有较大的值，通过变量进行临时存储
让每个元素进行比较，记录较大值，都比较完成，该变量就是最大值
定义变量，初始化为数组中任意一个 元素即可
        通过循环语句进行遍历
最大值赋值给变量
定义功能
1明确结果 最大元素int 
2未知内容 一个数组  int【】*/
public static int getMax(int[] arr)
  {
int max =arr[0];
   for (int x=1;x<arr.length ;x++ )
   {


if(arr[x]>max)
max= arr[x];
   }
return max;
       }
/*获取最大值的另一种方式
把max初始化为0可不可以？可以这种原理是在初始化为数组中任意一个角标
*/
public static int getMax_2(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];
}
//获取double类型数组最大值，因为功能一致，所以函数名称一致，以重载形式存在
public static double getMax(double[] arr1)
{
double max=arr1[0];
for (int x=1;x<arr1.length ;x++ )
{
if (arr1[x]>max)
{
max=arr1[x];
}
}
return max;
}


}