java基础语言

 项目取名建议：
域名反写 .        项目名称 .          模块名称 .          类名 
cn.tedu.          aproject.      studentmanager.    ****

当程序的运行结果与你所预期的结果不同时:
1.打桩: System.out.println(数据);
2.Debug调试工具:首先要添加断点(双击)
  1)掌握四个键:
    1.1)F5:单步调试(会进入到方法中)
    1.2)F6:逐过程调试(不会进入到方法中)
    1.3)F7:结束方法的调试(返回)
    1.4)F8:直接跳到下一个断点(若后面无断点则调试结束)
  2)会看两个东西:
    2.1)会看变量
    2.2)会添加监视(选中表达式右键Watch)
————————————————————————————
                              基础语言：
————————————————————————————
1.Java开发环境：
  1）Java编译运行过程：
  1.1）编译器：.java源文件，经过编译，生成.class字节码文件
  1.2）运行期：JVM加载.class并运行.class
  跨平台，以此编程到处使用
 2）JVM：Java虚拟机
              加载.class并运行.class
 3） JRE:java运行环境
            JRE=JVM+Java系统类库（小文件）
      JDK：java开发工具包
              JDK=JRE+编译，运行等命令工具
2.eclipse：
   IBM，开源的，免费的
   新建项目，新建包，新建类

练习：
1）新建java项目Myproject
2）再Myproject中新建包java包mypackage
3）在mypackage中新建java类MyClass，main中：
     输出HelloWorld并换行
4）在mypackage中新建java类Test，main中：
     输出Hello，不换行
     输出World，换行
     输出当日事当日毕，换行
     输出.....
——————————————————————————————————
1.变量:存数的，代词，指代的就是它所存的那个数
  1)声明:
      int a; //声明一个整型的变量，名为a
      int b,c,d; //声明三个整型的变量，名为b,c,d
  2)初始化:第一次赋值
      int a = 250; //声明整型变量a并赋值为250
      int a;   //声明整型变量a
      a = 250; //给变量a赋值为250
      a = 360; //修改变量a的值为360
  3)使用:
    3.1)对变量的操作就是对它所存的那个数的操作
          int a = 5;
	  int b = a+10; //取出a的值5，加10后，再赋值给变量b
	  System.out.println(b);   //输出变量b的值15
	  System.out.println("b"); //输出b，双引号中的原样输出
          a = a+10; //取出a的值5，加10后，再赋值给变量a
	            //在a本身基础之上增10
    3.2)变量的使用必须与数据类型匹配
          int a = 3.14; //编译错误，数据类型不匹配
    3.3)变量在用之前必须声明并初始化
          System.out.println(m); //编译错误，m未声明
	  int m;
	  System.out.println(m); //编译错误，m未初始化
  4)命名:
    4.1)只能包含字母、数字、_和$符，并且不能以数字开头
    4.2)严格区分大小写
    4.3)不能使用关键字
    4.4)可以中文命名，但不建议
        建议"英文的见名知意"、"驼峰命名法"
2.基本数据类型:
  1)int:整型，4个字节，-21个多亿到21个多亿
    1.1)整数直接量默认为int型，但不能超出范围，超范围则编译错误
    1.2)两个整数相除，结果还是整数，小数位无条件舍弃
    1.3)整数运算时超出范围则发生溢出，溢出不是错误，但是是需要避免的
  2)long:长整型，8个字节，很大很大很大
    2.1)长整型直接量需在数字后加L或l
    2.2)运算时若有可能溢出，建议在第1个数字后加L
    2.3)System.currentTimeMillis()用于获取自
        1970.1.1零时到此时此刻的毫秒数
  3)double:浮点型，8个字节，很大很大很大
    3.1)浮点数直接量默认为double型，表示float需在数字后加f或F
    3.2)double和float数据在运算时，有可能会出现舍入误差
  4)boolean:布尔型，1个字节
    4.1)只能赋值为true和false
  5)char:字符型，2个字节
    5.1)采用Unicode字符集编码，一个字符对应一个码，
        表现的形式的字符char，但实质上是码int
	(ASCII码: 'a'--97  'A'--65  '0'--48)
    5.2)字符直接量必须放在单引号中，只能有一个
    5.3)特殊符号需通过\来转义
3.基本数据类型间的转换:
    基本数据类型从小到大依次为:
       byte,short,int,long,float,double
               char,
  1)两种方式:
    1.1)自动类型转换:小类型到大类型
    1.2)强制类型转换:大类型到小类型
          (要转换成为的数据类型)变量
	  强转有可能溢出或丢失精度
  2)两点规则:
    2.1)整数直接量可以直接赋值给byte,short,char，但不能超出范围
    2.2)byte,short,char型数据参与运算时，先一律转换为int再运算
4.Scanner接收输入:
  1)在package下:
      import java.util.Scanner;
  2)在main中:
      Scanner scan = new Scanner(System.in);
  3)在第2步之下:
      System.out.println("请输入年龄:");
      int age = scan.nextInt();
      System.out.println("请输入价格:");
      double price = scan.nextDouble();

Scanner原理：  
         import java.util.Scanner; //定义import，因为Scanner不再一个类里，用import.java.util.Scanner调用Scanner；
         Scanner scan = new Scanner(System.in);   //调过后就直接用Scanner
         int a = scan.nextInt();           //给方法赋值
         double b = scan.nextDouble();//给方法赋值
         String c = scan();//给方法赋值
Scanner--前世↓：
         package java.util;    //Scanner项目，(系统自带)。
          class Scanner{   //Scanner 类
           Scanner(Stream s){  //构造 Scanner 有参
            }
            int nextInt(){  //方法
           }
           double nextDouble(){  //方法
            }
            String next(){   //方法
            }

练习：
1）创建类Agerange,要求
      接收用户输入的年龄age，并输出
2）创建类LeapYear，要求
     接收用户输入的年份year，并输出
3）创建类Cashier，要求
编写一个收银柜台收款程序。根据商品单价、购买数量以及收款金额计算并输出应收金额和找零
———————————————————————————————————
运算符：
   1）算术：+，-，*，/，%，++，--
   2）关系：>,<,>=,<=,==,!= ,boolean
   3)逻辑：&&,||,!,boolean
   4)赋值：=,+=,-=,*=,/=,%=
   5)字符串连接：+
   6）条件三目运算符：boolean?数1：数2

练习：  
1）创建类ScoreLevel，要求：
     接收用户输入的成绩Score，并输出
2）创建类CommandBySwich，要求：
    接收用户输入的命令command，并输出
3）完成经典案例：--------至少两次
   3.1）AgeRange年龄判断程序
   3.2）LeapYear闰年判断程序
   3.3）Cashier柜台收银程序

————————————————————————————————
1.分支结构:
  3)if...else if结构:多条路
    if(){
     }else if(){}
  4)switch...case结构:多条路
      switch(){
       case 1:
           break; //跳出循环，满足条件不执行下面语句
       case *:
            }
    优点:效率高、结构清晰
    缺点:对整数做相等运算
    break:跳出switch
   switch...case能做到的if ...else结构都能做到。
2.循环:反复执行一段相同或相似的代码
3.循环三要素:
  1)循环变量的初始化
  2)循环的条件(以循环变量为基础)
  3)循环变量的改变(向着循环的结束变)
  循环变量:在整个循环过程中所反复改变的那个数
4.循环结构:
  1)while:先判断后执行，有可能一次都不执行
      while(){}
  2)do...while:先执行后判断，至少执行一次
       do{
            }(while);
               要素1与要素3相同时，首选do...while               
	
练习:
1.完成经典案例:
     1)ScoreLevel成绩等级判断
     2)CommandBySwitch命令解析程序
     3)Guessing猜数字之while
     4)Guessing猜数字之do...while
————————————————————————————————
1.循环结构:
  3)for:应用率最高，固定次数循环
      for(int a = 0;int a <= 100;a++ ; ){}
    特殊for表达式for(int a = 9;int a <= 999999;a=a*10+9 ; ){
                  //a就以实现初值9，99，999....累加        }
2.break:跳出循环
  continue:跳过循环体中剩余语句而进入下一次循环
3.三种循环结构的更佳适用情况:
  1)while:"当..."循环
  2)do...while:"直到..."循环
               要素1与要素3相同时首选do...while
  3)for:固定次数循环，应用率最高
4.嵌套循环:
  1)循环中套循环，一般多行多列时使用时，外层控制行，内层控制列
  2)执行规则: 外层循环走一次，内层循环走所有次
  3)建议:嵌套层次越少越好，能用一层就不用两层，能用两层就不用三层
    若需求必须通过三层以上的循环才能解决，说明设计有问题
  4)break只能跳出一层循环
5.程序=算法+数据结构-----------了解
  1)算法:解决问题的流程/步骤(顺序、分支、循环)
  2)数据结构:将数据按照某种特定的结构来保存
             数怎么存
    设计良好的/合理的数据结构会导致好的算法
6.数组:
  1)是一种数据类型(引用类型)
  2)相同数据类型元素的集合
  3)数组的定义:
      int[] arr = new int[10];
  4)数组的初始化:
      int[] arr = new int[4]; //0,0,0,0
      int[] arr = {3,5,7,9}; //3,5,7,9
      int[] arr = new int[]{3,5,7,9}; //3,5,7,9
      int[] arr;
      arr = {3,5,7,9}; //编译错误，此方式必须声明同时初始化
      arr = new int[]{3,5,7,9}; //正确
  5)数组的访问:
    5.1)通过(数组名.length)可以获取数组的长度(元素的个数)
          int[] arr = new int[4];
	  System.out.println(arr.length); //4
    5.2)通过下标/索引来访问数组中的元素
        下标从0开始，最大到(数组的长度-1)
	  int[] arr = new int[3];
          arr[0] = 100; //给第1个元素赋值为100
	  arr[1] = 200;
	  arr[2] = 300;
	  arr[3] = 400; //运行时发生数组下标越界异常
	  System.out.println(arr[arr.length-1]); //输出最后一个元素的值
  6)数组的遍历:
      int[] arr = new int[10];
      for(int i=0;i<arr.length;i++){
        arr[i] = (int)(Math.random()*100);
      }
      for(int i=0;i<arr.length;i++){
        System.out.println(arr[i]);
      }
      for(int i=arr.length-1;i>=0;i--){
        System.out.println(arr[i]);
      }


练习:
1.完成经典案例:
  1)随机加法运算器
  2)九九乘法表
  3)求数组元素的最大值
——————————————————————————————————
1.数组:
  7)数组的复制:
          int[] arr=new int[10];
    7.1)System.arraycopy(arr,1,arr1,0,4);  //效率高，灵活性好
  例： int[] a = {10,20,30,40,50};
         int[] a1 = new int[6];  //arr:源数组，1：源数组的起始下标，a1：目标数组，0：目标数组的起始下标，4：要赋值都元素个数
         System.arraycoyp(a,1,a1,0,4);
         for(int i =0;i<a1.length;i++){
         System.out.println(a1[i]);}
    7.2)int[] arr1  = Arrays.copyOf(arr,6);//效率低，灵活性差
      例： int[] a = {10,20,30,40,50};//a:源数组，a1：目标数组，6：目标数组的长度
             int[] a1 = Arrays.copyOf(a,6);
             for(int i = 0; i <a1.length;i++){
             System.out.println(a1[i]);
     //扩容:arr = Arrays.copyOf(arr,arr.length+1); 
            扩容需要定义: import java.util.Arrays;	
      例： int[] a = {10,20,30,40,50};
      //数组都扩容（创建了一个新的数组并将源数组数据复制过去了）
             a = Arrays.copyOf(a,a.length+1);
             for(int i = 0;i<a.length;i++){
            System.out.println(a[i]);
            输出结果为：10 20 30 40 50 0
   一个值放到扩容后的最后一个位置：
     arr[arr.length-1] = *;
  8)数组的排序:
    8.1)Arrays.sort(arr); //效率高
    8.2)冒泡排序:
        8.2.1)5个数冒4轮
	8.2.2)每一轮都是从第1个元素开始冒
	      每一次都是和它的下一个元素比
	8.2.3)冒出来了就不带它玩了
       例：int[] arr={67,23,4,56}; //升序
            for(int i = 0;i<=arr.length-1;i++){ //控制轮
             for(int j = 0;j<arr.length-1-i；j++）｛ //控制轮   ，
                                    arr.length-1-i
                 i = 0(第一轮)   比3次（ 3次来源：arr.length-1	）
                 i=1(第二轮)    比2次
                 i=2(第三轮)    比1次
               if(arr[j]>arr[j+1]){
                 int t = arr[j];  //int t 是空值，用来2个数之间位置交换
                 int[j] = arr[j+1]
                 int[j+1] = t;                     
                 }}}System.out.println("排序后:");
                   for(int i=0;i<arr.length;i++){
                   System.out.println(arr[i]);}
2.方法:
  1)封装一段特定的业务逻辑功能
  2)尽可能的独立，一个方法只干一件事
  3)被反复调用多次
  4)可以减少代码重复，有利于代码的维护，有利于团队的协作
3.方法的定义:
    修饰词 返回值类型 方法名(参数列表){
      方法体
    }
4.方法的调用:
  1)无返回值: 方法名(有参传参);
     在main里面直接调
   例：
    public static void main(String[] args){
      aa();} //直接调用，输出方法aa里的值
     public static void aa(){
    System.out.println("现在都生活或许不是你想要的，但一定是你自找的");} //定义无参方法
  2)有返回值: 数据类型 变量 = 方法名(有参传参);
   public static void main(String[] args){
       cc("ccx",21);}  //输出 你好，我叫ccx，今年21岁了。｝

   public static void cc(String name,int age){
      System.out.println("你好，我叫"+name+",今年"+age+"岁了");}  //定义有参方法
5.return:
  1)return 值; //1.1)结束方法的执行 1.2)返回结果给调用方
               -----------用在有返回值的方法中
           public static void main(String[] args){
           方法1；
            int aa = plus(5,6); //有返回值 int num1,num2；
            System.out.println(aa)；  //输出结果为11.  因为返回的是sum，            sum=num1+num2；
           方法2：  int m = 5 , n = 6; 
                        int aa = plus(m,n); 
                   System.out.println(aa); // 结果与方法1相同
            public static int plus(int num1,int num2){//int型
            int sum = num1+num2;
            return sum;}   //sum = num1+num2----有参有返回值
    
  2)return;    //2.1)结束方法的执行
               -----------用在无返回值的方法中
   public static void main(String[] args){
    double a = d();   //定义一个double赋值给a，再调d的值。并输出
    System.out.println(a);
    public static double d( ){ // 有返回值无参时，return需要赋值
        return 88.88;}

return用于结束时：
      public static void main(String[] args){
      d("ccx",30);   //调用d
       public static void d(String name,int age){
        if(age>50){
           return;}    // 结束方法，当age大于50，结束该语句
                System.out.println("大家好，我叫"+name+"今年"+age+"岁了");
                           }

练习；
1）完成经典案例：
   1.1）将数组元素最大值放在数组最后一个元素的下一个位置
    1.2）BubbleSort冒泡排序
——————————————————————————————————
1.猜字符小游戏目的:
  1)对前面6天所学知识更熟练的掌握
  2)了解开发一个程序的步骤

程序=结构+算法

猜字符小游戏:
1.设计数据结构:变量
  1)char[] chs;   //随机字符数组
  2)char[] input; //用户输入的字符数组
  3)int[] result; //对比结果
  4)int score;    //得分
2.设计程序结构:方法
  1)主方法:
    public static void main(String[] args){
      //...
    }
  2)生成随机字符数组:
    public static char[] generate(){
      char[] chs = new char[5];
      //...
      return chs;
    }
  3)对比:随机字符数组chs与用户输入的字符数组input
    public static int[] check(char[] chs,char[] input){
      int[] result = new int[2];
      //...
      return result;
    }
3.设计算法:方法体
      String str = "abc";
  1)将字符串转换为字符数组:
      char[] input = str.toCharArray();
  2)将字符串转换为大写字母:
      str = str.toUpperCase();
    将字符串转换为小写字母:
      str = str.toLowerCase();
  3)判断字符串内容是否相等:
      if(str.equals("EXIT")){
      }

主流程:
1)手里面藏一个数chs
2)猜吧!接收用户输入的一个数input
3)对比:chs与input
  3.1)若猜对了，则算分并输出---结束循环
  3.2)若猜错了，提示字符对个数和位置对个数，继续第2步