1、基础知识

2019-06-20  本文已影响0人  浮生若梦OvO

一、配置Java环境变量

二、常识知识

三、java语言的基本组成

C:第三种格式
if(条件表达式1)
{
语句体1;
}
else if(条件表达式2)
{
语句体2;
}
...
else
{
语句体n;
}
执行流程：
如果条件表达式1为true，就执行语句体1；
否则如果条件表达式2为true，就执行语句体2；
...
否则，就执行语句体n；
D:注意事项
a:什么时候时候用哪一种if语句。
第一种格式在判断条件为一种情况下使用。
第二种格式在判断条件为两种情况下使用。
第三种格式在判断条件为多种情况下使用。
b:每一种if语句其实都是一个整体，如果有地方执行了，
其他的就不执行了。
c:如果if或者else里面控制的语句体是一条语句，是可以省略大括号的，
但是，如果是控制多条语句，就必须写上大括号。
建议：永远写上大括号。
d:大括号和分号一般不同时出现。

E:作用域
所有变量的定义只在它所属的大括号内有效。
2、选择语句
switch语句
(1)用于做选择使用的。一般用于几个常量的判断。
switch会把几个常量值直接加载到内存，在判断的时候，效率要比if高。
所以，针对几个常量的判断，一般选择switch语句。
(2)switch语句的格式：
switch(表达式)
{
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
case 值3:
语句体3;
break;
...
default:
语句体n;
break;
}
A:针对格式的解释
switch:表示这里使用的是switch语句，后面跟的是选项。
表达式：byte,short,int,char
JDK5以后可以是枚举
JDK7以后可以是字符串
case:表示这里就是选项的值，它后面的值将来和表达式的值进行匹配。
case后面的值是不能够重复的。
break:
switch语句执行到这里，就结束了。
default:
当所有的case和表达式都不匹配的时候，就走default的内容。
它相当于if语句的else。一般不建议省略。
B:执行流程
进入switch语句后，就会根据表达式的值去找对应的case值。
如果最终没有找到，那么，就执行default的内容。
C:注意事项：
a:default整体可以省略吗?
可以，但是不建议。
b:default的位置可以放到前面吗?
可以，但是不建议。
c:break可以省略吗?
可以，但是不建议。
default在最后，break是可以省略的。
case后面的break可以省略，但是结果可能有问题。
d:switch语句什么时候结束呢?
就是遇到break或者执行到程序的末尾。
增加：Scanner的使用
(1)Scanner是JDK5以后设计的用来接收键盘录入数据使用的。
(2)目前我们要通过键盘录入int类型数据,必须按照如下步骤：
A:导包
import java.util.Scanner;
B:创建对象,封装键盘录入
Scanner sc = new Scanner(System.in);
C:调用方法,获取数据
int number = sc.nextInt();
3、循环结构
A:while 格式：
初始化条件;
while(判断条件)
{
循环体;
控制条件;
}
执行流程：
a:先执行初始化条件;
b:执行判断条件
c:根据判断条件的返回值：
true:执行循环体。
false:就结束循环。
d:最后执行控制条件。返回到b继续。

B:do...while格式：
初始化条件;
do{
循环体;
控制条件;
}while(判断条件);
执行流程：
a:先执行初始化条件;
b:执行循环体和控制条件;
c:执行判断条件
d:根据返回值
true:返回b。
false:就结束循环。
C：for格式：
for(初始化条件;判断条件;控制条件)
{
循环体;
}
执行流程：
a:先执行初始化条件;
b:执行判断条件
c:根据判断条件的返回值：
true:执行循环体。
false:就结束循环。
d:最后执行控制条件。返回到b继续。
注意：
a:一般使用for循环或者while循环。而且这两种循环是可以等价转换的。
b:do...while循环至少执行一次循环体。

D循环嵌套：
A:也就是循环语句的循环体是一个循环语句。
B:外循环控制行数，内循环控制列数。
C:正三角形
内循环的判断条件：y<=x
for(int x=0; x<5; x++)
{
for(int y=0; y<=x; y++)
{
System.out.print("");
}
System.out.println();
}
E:倒三角形
内循环的初始化条件：y=x
for(int x=0; x<5; x++)
{
for(int y=x; y<5; y++)
{
System.out.print("");
}
System.out.println();
}
F：99乘法表
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();
}
G:水仙花数
请输出满足这样条件的五位数。
个位=万位
十位=千位
个位+十位+千位+万位=百位
思路：
1.定义一个要操作的五位数变量num
2.求出每一位个系数
个：num%10
十：num/10%10
百：num/100%10
千：num/1000%10
万：num/10000%10
3.根据题意确定范围10000-99999，变化规律是+1
4.判断是否符合题意中的要求，符合的话输出num
代码：
for(int num = 10000; num <100000;num++)
{
int ge = num%10;
int shi = num/10%10;
int bai = num/100%10;
int qian = num/1000%10;
int wan = num/10000%10;
if(ge == wan && shi == qian && (shi+ge+qian+wan) == bai)
{
System.out.println(num);
}
}

G：break和continue关键字
(1)有些时候，我们需要对循环进行一些控制终止,这个时候，就出现了两个关键字：
break和continue
(2)特点：
A:它们都必须在循环中(break还可以在switch中。)。
一般在循环的判断中。
B:如果单独使用break和continue，后面是不能有语句的。
(3)区别：
A:break 结束当前循环。
B:continue 结束本次循环，进入下一次循环。
(4)如何退出嵌套循环：(了解)
用带标签的循环。
格式:
标签名：for(){
for(){
if()
{
break 标签名;
}
}
}

H:应用场景
(1)当要对某些语句执行很多次时，就使用循环语句；特别要明确那些语句要参与循环，那些不要参与；

public static int sum(int a,int b){...}
public static int sum(int a,int b,int c){...}
public static int sum(float a,float b){...}

6、数组
1、概念：同一种类型数据的集合，其实数组就是一个容器。
2、好处：数组可以自动给数组中的元素从0开始编号，便于操作。
3、格式：

          A:int[] arr = new int[3];
          B:int arr[] = new int[3];
          C:int[] arr = new int[]{1,2,3};
          D:int[] arr = {1,2,3};

4、Java内存图：

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

public static void selectSort(int[] arr)
{
     for (int x=0;x<arr.length-1 ;x++ )//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++)//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 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.print(arr[x]+"]");
          }
     }
}

public static void reverseArray(int [] arr)
{
     for(int start=0,int end=arr.length-1; start<end ; start++,end--)//定义变量控制首尾位置
          {
               int temp = arr[start];//交换位置
               arr[start] = arr[end];
               arr[end] = temp;
          }
}

public static int halfSerach(int[] arr,int key)
{
     int min=0;
     int max=arr.length-1;
     int mid=(min+max)/2;
     while (arr[mid]!=arr[key])
     {
          if (arr[key]>arr[mid])//判断key与数组中间元素值的大小，然后改变相应的min和max；
          {
               min=mid+1;
          }
          else if (arr[key]<arr[mid])
          {
               max=mid-1;
          }
          if (min>max)//判断出现min大于max则数组中key不存在；
          {
               return -1;
          }
          mid=(min+max)/2;//每循环一次，改变mid的值
     }
     return mid;
}

class HexConversion
{

     //十进制-->二进制
    
     public static void toBin(int num)
     {
          trans(num,1,1);
     }

    
     //十进制-->八进制
    
     public static void toBa(int num)
     {
          trans(num,7,3);
     }
    
     //十进制-->十六进制
     public static void toHex(int num)
     {
          trans(num,15,4);
     }

     public static void trans(int num,int base,int offset)
     {
     if (num==0)//0不需要转换
     {
          System.out.println(0);
     }
     char[] chs = {'0','1','2','3',
                      '4','5','6','7',
                      '8','9','A','B',
                      'C','D','E','F'};//设置数组
     char[] arr = new char[32];//定义一个容器，用于接收&运算后的值，所对应的chs数组中的元素。

          int pos = arr.length;

          while(num!=0)
          {
               int temp = num & base;//获取二进制最后的base位数值
               arr[--pos] = chs[temp];
               num = num >>> offset;//获取所有二进制位的所有值。
          }

          for(int x=pos; x<arr.length; x++)
          {
               System.out.print(arr[x]);//将arr[]数组打印
          }

          return ;
     }
}


  格式：
               A:int[][] arr = new int[3][2];
               B:int[][] arr = new int[3][];
               C:int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
     注：int[]x,y[]<=>int[]x,int[]y[];
    二维数组的遍历：
int [][]arr = {{2,3,6},{4,5,8},{2,4,8,9}};
for(int x=0;x<arr.length;x++)
{
     for(int y=0;y<arr[x].length;y++)
     {
          System.out.print(arr[x][y]+"\t");
     }
     System.out.println();
}
上一篇 下一篇

猜你喜欢

热点阅读