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;

}

}