Java基础

初识Java

1.jvm   Java运行的平台

 jre   Java运行的环境，包含了jvm和Java程序所需要的核心类库，如果只要运行Java程序只要安装jre即可

 jdk   Java开发者工具包，包含了提供给开发人员的工具（javac  jre.exe.....）,包含jre

  最终 只要安装JDK即可  JDK开发Java程序  交给JRE运行

2.记事本开发Java程序三步骤

  1.编写  

    1创建记事本

    2修改后缀.java

    3编写程序 结构

public class oneDay{

      public static void main(String [] args){

         System.out.println("第一天的程序");

     }

    }

   oneDay 文件名

   public static void main(String [] args) main方法的入口

   System.out.println("第一天的程序");     语句的输出

  2.编译

   javac oneDay.java

  3.运行

  java oneDay

3.  Java的程序结构

1、类名与文件名完全一样，首字母大写

         2、main()程序入口，四要素必不可少

         3、System.out.println()从控制台输出信息，S大写,输出信息要加””

         4、{和}一一对应，缺一不可

         5、注意首行缩进

         6.每行代码编写完一定要加;

4.注释

 //注释：1. //单行注释

         //     2./ /多行注释

         //在企业开发中  单行注释用在方法内  多行方法外

         //               3javaDoc文档注释  / /    导出--java---javadoc

         //注意：注释不会被编译

/**

           *name:sunwen

           *time:2017-8-8

           *@param args

         * /

数据类型和变量

1个字节等于一个8位的二进制【如：0000-0000】

1.数据类型    

          1整型

           byte  -128~+127

           short -32768~ + 32767

           int   -2147483648~ + 2147483647

           long   -2↑63  ~ + 2↑63-1

           注意点 默认直接写 整形  默认的类型是int

          

         2浮点数【小数】

           float 1.4E-45 ~ 3.4E+38 , -1.4E-45 ~ -3.4E+38

           double 4.9E-324 ~ 1.7E+308, -4.9E-324 ~ -1.7E+308

           注意 默认小数为 double

          3.字符

          char  存放单个字符

         注意  值用单引号括起来

           4boolean

           取值 true false

           5字符串

           String

         注意 值必须加“”

          2. 变量的命名规范

           字、下、美、人、数、骆驼

           1变量必须由 字母 数字下划线_ 美元符号$组成

           2.不能以数字开头

           3.不能以关键字作为变量

           4.命名要见名之意

           驼峰命名法

           首字母小写其后的单词首字母大写 如【oneDayNum1】

 

3. 运算符号

           +    -        /【结果是商】      %【结果是余数】         

            ++【++就是自身+1      ++写在前面先++在赋值   ++写在后面 先赋值后++】     

           --【++就是自身-1      --写在前面先--在赋值   --写在后面 先赋值后--】

          

         复合运算符

         +=、-=、=、/=、%=

         三元运算符

         数据类型   变量=条件判断？值1：值2 【 条件判断结果false  值 2      true 选择值1】

 

4. 自动类型转换

           小类型转大类型 自动类型转换

           两种类型要兼容：

                   数值类型（整型和浮点型）互相兼容

                   目标类型大于源类型：

                   例如：double 型大于 int 型

          

         强制类型转换

         由大类型转小类型

         格式：数据类型  变量=（数据类型）大的数据类型；

         注意;会有精度的丢失

 

5.Scanner的使用

第一步引入scanner的空间importjava.util.Scanner;

         第二步 实例化scanner类    Scanner 变量名=newScanner(System.in);

         第三步 调用其方法 接收键盘输入的值

               1.next() 接收键盘输入的字符串

               2.nextInt()  接收键盘输入的整数值

               3.nextDouble()  接收键盘输入的小数

选择结构

1.单分支

  语法

if(条件判断){

    条件判断返回true执行的代码块

          }

         判断  【关系运算符】

         >  < >=  <=  !=  ==

2.多分支

           if else选择结构

           语法

if(条件判断){

              条件判断满足执行的代码块

         }else{

               条件判断不满足执行的代码块

          }

3. 多重if else选择

         语法

 if(){

          

          }else if(){

          

          }esle{

                   

          }

         注意 else if()    可以多写

             else       可写可不写

 

4. 字符串的比较

                   //方法 ：equals

调用equals 方法比较

  if(iSex.equals("男")){

                            System.out.println("靓仔");

                   }

5. if的嵌套

if(  ){

            if (  ) {

               if(  ){

              

               }

            }

          }

6. 逻辑运算符

           &&    并且                两端的条件只要有一个不满足 返回false

           ||     或者                  两端的条件只要有一个满足 返回true

   注意：前面的一个条件如果满足 将不会判断||后面的条件

         ！             不，非                          取反

          随机数

intrandom=(int)(Math.random()10);

intrandom=(int)(Math.random()(上限-下限+1)+下限);

7. switch 分支结构

switch (表达式) {

     case 常量 1:

                   语句;

                   break;

      case 常量 2:

                   语句;

                   break;
         …

            default:

                   语句;
}

     注意点：1 每个分支结束都需要添加break

         2 default 必须写在最后

         3 case的值  不能重复

         4 多个case 可以写在一起作用于同一块代码

         5.表达式1.6不支持字符串

                             

循环结构

1. 环环结构三要素

           1循环初始值

      2循环条件

      3循环次数的累加

           while循环结构

变量的初始值                                        //只会执行一遍

           while(循环的条件判断){

            循环体

              变量的累加                                    //可以更具业务的需求而 定义

          }

         程序的调试

           作用：查找错点     看清程序的运行步骤以及变量的变化

           步骤：1打断点

                 2Debug

                 3观察程序的运行 以及变量的变化

2. dowhile特点

           先执行 后判断

           条件不满足 至少执行一次

         结构

 do{

                           

           }while();

3. for循环

          循环次数固定    使用简介

          结构

 for(表达式1；表达式2；表达式3){

             循环体

           }

          for循环  可以写多个初始值  判断  迭代

4.      break;

         作用 跳出整个循环 

5.continue

           只能用于循环

           作用 ：跳出本次循环  进入下一次新的循环

 

数组

1. 数组

         在内存中开辟了一段连续的空间

          注意点

          不能放入比开辟空间大的元素【下标不能越界】

          数组声明之后  空间固定

 

数组的声明1

定义数组

                   int[] nums;

                   intnums [];

                   分配空间     给nums分配了5个连续的空间  对应的下标0 1 2 3 4

                   nums=newint[5];

                  

                   数组的声明2   给nums2分配了5个连续的空间  对应的下标0 1 2 3 4

                   int[] nums2=new int[5];

                  

                   数组的声明3  电定义nums3数组 并赋值    通过赋值的个数来确定数组的空间

                   int[] nums3={1,2,3,4,5};

                   int[] nums3=new int[]{1,2,3,4,5};

如何赋/取值      

声明可一个int类型数组 在内存中分配了5个连续的空间

                   int[] num=new int[5];

                     通过下标可以指向数组中的某一个元素

                    格式：num[下标]


                  赋值     可以不按顺序   

                   num[0]=1;

                   num[1]=2;

                   num[2]=3;

                   num[3]=4;

                   num[4]=5;


                   num[2]=33;


                  取值

                   intn2=num[1];

                   System.out.println(n2)

2. 数组名.lenght    获取数组的长度

3. 比大小

int[] num={50,40,66,99,2};

                   //定义第一个为最大的

                   int max=num[0];

                            //循环比较

                   for(inti=1;i<num.length;i++){

                            if(num[i]>max){

                                     max=num[i];

                            }

                   }


                   //输出最大值

                   System.out.println("最大值"+max);

4. 插入算法

         降序

         1.找刚刚好比插入的数小的数   记录其位置【下标】

         2.将该位置包括该位置往后的元素全部向后挪一位

         3.将插入的元素 放入标记的位置

 //定义数组

         int[] score=new int[6];

         //赋值

         score[0]=99;

         score[1]=85;

         score[2]=82;

         score[3]=63;

         score[4]=60;

         //定义输入类

         Scannerinput=new Scanner(System.in);

         System.out.print("请输入新成绩");

         intnewScore=input.nextInt();

                  

         //定义一个变量  记录插入的下标

   int index=0;

   //1.找刚刚好比插入的数小的数   记录其位置【下标】

         for(inti=0;i<score.length;i++){

                   if(newScore>score[i]){

                            index=i;

                                     break;

                            }

                   }


                   //2.将该位置包括该位置往后的元素全部向后挪一位

                   for(inti=score.length-1;i>index;i--){

                            score[i]=score[i-1];

                   }

                   //3.将插入的元素 放入标记的位置

                   score[index]=newScore;

                   //输出插入之后的数组

                   for(ints : score){

                            System.out.print(s+"");

                   }                           

5.冒泡排序

int[] num={80,65,2,-4,100};

                   //外层控制4轮

                   for(inti=0;i<num.length-1;i++){

                            //每轮的比较次数

                            for(intj=0;j<num.length-i-1;j++){

                                     if(num[j]>num[j+1]){

                                               intt=num[j];

                                               num[j]=num[j+1];

                                               num[j+1]=t;

                                     }

                            }

                   }

增强for循环，遍历数组

                   for(intn : num){

                            System.out.print(n+"");

                   }

6.二维数组

定义二维数组

                   int[][] score=new int[3][5];

                   int[][] score1={{1,2,3,4,5},{2,2,3,4,5},{3,3,3,4,5}};    

                   //如何遍历

                   //1种

                   for(inti=0;i<score1.length;i++){

                            int[] sc=score1[i];

                            for(intj=0;j<sc.length;j++){

                                     System.out.print(sc[j]+"");

                            }

                            System.out.println();

                   }

                   //2种

                   for(inti=0;i<score1.length;i++){

                            for(int j=0;j<5;j++){

                                     System.out.print(score1[i][j]+"");

                            }

                            System.out.println();

                   }

7.Arrays         

//equals  比较两个数组是否相等

                   int[] num1={1,2,3};

                   int[] num2={1,2,3};

         System.out.println(Arrays.equals(num1, num2));

                  

                  

                  //sort对数组的元素进行升序排列

                  int [] num1={3,2,5};

                   Arrays.sort(num1);

                   for(intn : num1){

                            System.out.print(n+"");

                   }

                                    

                   //toString  将一个数组转换成一个字符串

                   int[] num1={3,2,5};

                   System.out.println(Arrays.toString(num1));

                                     

                   //fill   把数组所有元素都赋值为某个值

                   int[] num1={3,2,5};

                   Arrays.fill(num1, 1);

                   for(intn : num1){

                            System.out.print(n+"");

             }

                  

                  

//copyOf  把数组array复制成一个长度为length的新数组，返回类型与复制的数组一致

                   int[] num1={3,2,5};

                   int[] num2;

                   num2=Arrays.copyOf(num1,num1.length);

                   System.out.println(num2.length);

                                    

//binarySearch  查询元素值val在数组array中的下标（要求数组中元素已经按升序排列）

                   int[] num1={1,2,5,20,100,999};

                   System.out.println(Arrays.binarySearch(num1,100));