java基础

• 目的：

  为了更好地组织类，Java提供了包制止，用于区别类名的命名空间。

• 包语句语法格式为：

  package  pkg1[.pkg2[.pkg3...]];
  
  

• 一般利用公司域名倒置作为包名；www.baidu.com com.baidu.www

• 为了能够使用某一个包的成员，我们需要在Java程序中明确导入包。使用“import”语句可以完成此功能

  import package1[.package1....]....;
  

11. Java Doc

    javadoc命令自动生成自己的api文档

    //当前文档下
    javadoc -encoding UTF-8 -charset UTF-8 Doc.java
    
    

参数信息

• @author 作者名
• @version 版本号
• @since 指明需要最早使用的jdk版本
• @param 参数名
• @return 返回值情况
• @throws 异常抛出情况

12. Java流程控制

    • Scanner对象

      • scanner类来获取用户的输入

      • Scanner s = new Scanner(System.in);
        

      • 通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般使用hasNNext()与hasNextLine()判断是否还有输入的数据。

      • next();

        空格为结束

        import java.util.Scanner;
        
        public class Demo01 {
            public static void main(String[] args) {
                //创建一个扫描器对象，用于接收键盘数据
                Scanner scanner = new Scanner(System.in);
                System.out.println("使用next方法接收:");
                //判断用户有没有输入字符串
                if (scanner.hasNext()){
                    //使用next方式接收
                    String str = scanner.next();
                    System.out.println("输出内容："+str);
                }
                //凡是输入IO流的类如果不关闭会一直占用资源，要成好习惯用完就关掉
                //IO流:输入输出
                scanner.close();
            }
        }
        
        

      • nextLine():

        Enter为结束

        import java.util.Scanner;
        
        public class Demo01 {
            public static void main(String[] args) {
                //创建一个扫描器对象，用于接收键盘数据
                Scanner scanner = new Scanner(System.in);
                System.out.println("使用nextLine方法接收:");
                //判断用户有没有输入字符串
                if (scanner.hasNextLine()){
                    //使用next方式接收
                    String str = scanner.nextLine();
                    System.out.println("输出内容："+str);
                }
                //凡是输入IO流的类如果不关闭会一直占用资源，要成好习惯用完就关掉
                //IO流:输入输出
                scanner.close();
            }
        }
        
        

    • scanner 进阶

      import java.util.Scanner;
      
      public class Demo01 {
          public static void main(String[] args) {
              //我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果；
              Scanner scanner = new Scanner(System.in);
              //和
              double sum = 0;
              //计算输入了多少数字
              int m = 0;
              //通过循环判断是否还有输入，并在里面对每一次进行求和统计
              //默认是真
              while (scanner.hasNextDouble()){
                  double x = scanner.nextDouble();
                  m = m + 1; //m++
                  sum = sum + x;
                  System.out.println("你输入了第"+m+"个数据，然后当前结果sum="+sum);
              }
              System.out.println(m + "个数的和为"+sum);
              System.out.println(m + "个数的平均值是"+(sum / m));
              scanner.close();
          }
      }
      
      

    • 顺序结构

      • java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。

      • 顺序结构是最简单的算法结构。

      • 语句与语句之间，框与框之间是按照从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的基本算法结构。

        public class Demo01 {
            public static void main(String[] args) {
                System.out.println("hello1");
                System.out.println("hello2");
                System.out.println("hello3");
                System.out.println("hello4");
            }
        }
        

    • 选择结构

      • if单选择结构

        import java.util.Scanner;
        
        public class Demo01 {
            public static void main(String[] args) {
                Scanner scanner = new Scanner(System.in);
                System.out.println("请输入内容：");
                String s = scanner.nextLine();
                //equals:判断字符串是否相等
                if (s.equals("hello")) {
                    System.out.println(s);
                }
                System.out.println("End");
                scanner.close();
        
            }
        }
        

      • if双选择结构

        if   else
        

      • if多选择结构

        if   else if else
        

      • 嵌套的if结构

      • switch多选择结构

​ 37——43没有看

13. Java方法

• 什么是方法
• System.out.println(),那它是什么呢？

​ System 类 out对象 println()方法

//一、第1步
    //public class Demo01 {
    //    //main方法，void表示方法值为空值
    //    public static void main(String[] args) {
    //
    //    }
    //
    //    //加法,因为这里写了方法类型是int，所以必须要return返回
          //加入static使方法变成类变量，可以进行调用
    //    public static int add(int a, int b) {
    //        return a + b;
    //    }
    //}
    //一、第2步，调用方法
    public class Demo01 {
        //main方法，void表示方法值为空值
        public static void main(String[] args) {
            int sum = add(1, 2);
            System.out.println(sum);

        }

        //加法,因为这里写了方法类型是int，所以必须要return返回
        public static int add(int a, int b) {
            return a + b;
        }
    }

• 设计方法的原则：方法的本意是功能块，就是实现某个功能的语句的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成1个功能，这样利于我们后期扩展

• 注意：main方法要时刻保持简洁和干净

• 方法的定义

  • java的方法类似于其他语言的函数，是一段用来完成特定功能的代码段，一般情况下，定义一个方法包含以下语法：

  • 方法包含一个方法头和一个方法体。下面是一个方法的所有部分:

    • 修饰符：可选的

    • 返回值类型：可能有，如：return Value Type

    • 方法名：驼峰型

    • 参数类型：参数像一个占位符

      • 形式参数
      • 实参

    • 方法体

       public class Demo01 {
              //main方法，void表示方法值为空值
              public static void main(String[] args) {
                  //add(1, 2)实际参数：实际调用传递给他的参数
                  int sum = add(1, 2);
                  System.out.println(sum);
      
              }
      
              //加法,因为这里写了方法类型是int，所以必须要return返回
              //add(int a, int b)形式参数，用来定义作用的
              public static int add(int a, int b) {
                  return a + b;
              }
          }
      

  ???值传递（java）和引用传递

  • 方法的重载

    • 重载就是在一个类中，有相同的函数名称，但形参不同的函数。
    • 方法的重载规则：
      • 方法名称必须相同。
      • 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。如：一个是doule 一个是int
      • 方法的返回类型可以相同也可以不相同。
      • 仅仅返回类型不同不足以成为方法的重载。
    • 实现理论：
      • 方法名称相同时，编译器回根据调用方法的参数个数，参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错

  • 命令行传参

    • java com******* ******

  • 可变参数（不定向参数）

    • JDK1.5开始，Java支持传递同类型的可变参数给一个方法。

    • 在方法声明中，指定参数类型后加一个省略号（…）。

    • 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

        public class Demo01 {
            public static void main(String[] args) {
                Demo01 demo01 = new Demo01();
                demo01.test(12,2,3);
                    }
            public void test(int x, int...i){
            }
        }
      

  • 递归(基数小的时候可以使用，如果不是建议不要使用)

    • A方法调用B方法，我们很容易理解！
    • 递归就是：A方法调用A方法！就是自己调用自己
    • 递归结构包含两部分：
      • 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
      • 递归体：什么时候调用自身方法。
      • 5！ 5 * 4 * 3 * 2 * 1
        • 5*f(4)

14. 数组（最简单的数据结构）

    • 数组概述

      • 数组是相同类型数据的有序集合。
      • 数组描述是相同类型的若干个数据，按照一定的先后次序排列组合而成。
      • 其中，每一个数据称作一个数组元素，每个数组可以通过一个下标来访问他们

    • 数组声明创建

      • 首先必须声明数组变量，才能在程序中使用数组。下面声明数组变量的语法：

        dataType[ ]   arrayRefVar；//首选方法
        dataType  arrayRefVar[ ] ；//效果相同。但是不是首选方法
        

      • java语言使用new *** 作来创建数组，语法如下：

        dataType[ ]  arrayRefVar = new dataType[arraySize]；
        

      • 数组的元素是通过索引访问的，数组索引从开始。

      • 获取数组长度：arrays.length

        public class Demo01 {
            public static void main(String[] args) {
                int[] nums;//1.声明一个数组
                nums = new int[10];//2.创建一个数组
                //3.给数组元素中赋值
                nums[0] = 1;
                nums[1] = 2;
                nums[2] = 3;
                nums[3] = 4;
                nums[4] = 5;
                nums[5] = 6;
                nums[6] = 7;
                nums[7] = 8;
                nums[8] = 9;
                nums[9] = 10;
              //如果不赋值，则直接返回0
                System.out.println(nums.length);
                //计算所有元素的和
                int sum = 0;
                //获取数组长度：array.length
                for (int i = 0; i < nums.length; i++) {
                    sum = sum + nums[i];
                    System.out.println("总和"+sum);
                }
            }
        }
        

        备注：

        Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException 数组下标越界异常

      • 内存分析

        • Java内存
          • 堆：
            • 存new的对象和数组
            • 可以被所有的线程共享，不会存放别的对象引用
          • 栈
            • 存放基本变量类型
            • 引用对象的变量
          • 方法区
            • 可以被所有的线程共享
            • 包含了所有的class和static变量、
        • 声明数组的时候，内存并不存
        • 创建数组的时候才存在，给予赋值的时候才有值，否则是默认元素

      • 三元初始化

        • 静态初始化

        • 动态初始化

        • 数组的默认初始化

          • 数组是引用类型，它的元素相当于类的实力变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

          public class Demo01 {
              public static void main(String[] args) {
                  //静态方法
                  int[] a= {1,2,3,4,5};
                  System.out.println(a[0]);
                  //动态初始化:包含默认初始化
                  int[]b = new int[10];
                  b[0] = 10;
                  b[1] = 10;
                  //不赋值时，int默认为0，str为null
                  System.out.println(b[0]);
                  System.out.println(b[1]);
                  System.out.println(b[2]);
              }
          }
          

          备注：数组是一个对象，对象是在堆中的，数组内只能是同个类型

          ​

    • 数组使用

      • 基本用法

        public class Demo01 {
            public static void main(String[] args) {
                int [] arrays = {1,2,3,4,5};
                //打印全部的数组元素
                for (int i = 0; i < arrays.length; i++) {
                    System.out.println(arrays[i]);
                }
                System.out.println("=========");
                //计算所有元素的和
                int sum = 0;
                for (int i = 0; i < arrays.length; i++) {
                    sum += arrays[i];
                }
                System.out.println("sum="+sum);
                System.out.println("=======");
                //查询最大元素
                int max = arrays[0];
                for (int i = 0; i < arrays.length; i++) {
                    if (arrays[i]>max){
                        max = arrays[i];
                    }
                    
                }
                System.out.println("max="+max);
            }
        }
        
        

      • 进阶用法

        public class Demo01 {
            public static void main(String[] args) {
                int[] arrays = {1,2,3,4,5};
                //JDK1.5 没有下标
        //        for (int array:arrays){
        //            System.out.println(array);
                打印数组元素，main方法内调用printArray
        //        printArray(arrays);
                //反转数组
                int[] reverse = reverse(arrays);
                打印反转数组，main方法内调用printArray
                printArray(reverse);
            }
            //反转数组
            public static int[] reverse(int[]arrays){
                int[] result = new int[arrays.length];
                //反转 *** 作
                for (int i = 0,j= result.length-1; i < arrays.length ; i++,j--) {
                    result[j]=arrays[i];
                }
                return result;
            }
        
                //打印数组元素
            public static void printArray(int[] arrays){
                for (int i = 0; i < arrays.length; i++) {
                    System.out.println(arrays[i]+"");
                }
            }
              }
            //不明白就debug
        
        

• 多维数据

  • 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组

  • 二维数组 P56

  int a[][] = new int[2][5];
  

  • 解析：以上二维数组a可以看成一个两行5列的数组

    public class Demo01 {
        public static void main(String[] args) {
            int [][] array = {{1,2},{3,4},{5,6},{7,8}};
            System.out.println(array[2][0]);
            System.out.println(array[2][1]);
        }
    }
    

• Arrays类（ *** 作数组的类）

  • 数组的工具类Java.util.Arrays
  • 由于数组对象本身并没有什么方法可以提供我们调用，但API中提供例如一个工具类Arrays供我们用，从而可以对数据对象进行一些基本的 *** 作。
  • 查看JDK帮助文档
  • Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意：是“不用”而不是“不能”）
  • 具有以下常用功能：
    • 给数组赋值：通过fill方法。
    • 对数组排序：通过sort方法，按升序。
    • 比较数组：通过equals方法比较数组中元素值是否相等。
    • 查找数组元素：通过binarySearch方法能对排序号的数组进行二分查找法 *** 作。
  • structur 英[ˈstrʌktʃə®] 结构

• 冒泡排序

  • 冒泡排序无疑是最为出名的排序算法之一，总共有八大排序！

  • 冒泡的代码还是相当简单的，两层循环，外层冒泡数，里层依次比较

  • 我们看到嵌套循环，应该立马就可以得到这个算法得时间复杂度为O(n2)。

    import java.util.Arrays;
    
    public class Demo01 {
        public static void main(String[] args) {
            int [] a ={1,4,5,6,7,10,1};
            int[] sort =  sort(a); //调用完我们自己写的排序方法以后，返回一个排序后的数组
            System.out.println(Arrays.toString(sort));
        }
        //冒泡排序
        //1.比较数组中，两个相邻得元素，如果第一个数比第二个数大，我们就交换他们的位置
        //2.每一次比较，都会产生出一个最大，或者最小的数字；
        //3.下一轮则可以少一次排序！
        //4.依次循环，直到结束！
        public static int[] sort(int[] array){
            //定义临时变量
            int temp = 0;
            //外层循环，判断我们这个要走多少次；
            for (int i = 0; i < array.length-1; i++) {
                //内层循环，比较判断两个数，如果第一个数，比第二个数大，则交换位置
                boolean flag = false; //通过flag标识减少没有意义的比较
                for (int j = 0; j < array.length-1; j++) {
                    if (array [j + 1]>array[j]){
                        temp = array[j];
                        array[j] = array [j + 1];
                        array[j+1] = temp;
                        flag = true;
                    }
                }
                if (flag==false){
                    break;
                }
                
            }
            return array;
        }
    }
    

    ​

• 稀疏数组（压缩数组，可以减少内存等）扩展

  • 当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。

  • 稀疏数组的处理方式是：

    • 记录数组一共有几行几列，有多少个不同值
    • 把具有不同的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

  • import java.util.Arrays;
    
    public class Demo01 {
        public static void main(String[] args) {
            //1.创建一个二维数组11*11  0:没有棋子，   1：黑棋   2：白棋
            int[][] array1 = new int[11][11];
            array1[1][2]=1;
            array1[2][3]=1;
            //输出原始的数组
            System.out.println("输出原始的数组");
            for (int[]ints:array1){
                for(int anInt:ints){
                    System.out.print(anInt+"t");
                }
                System.out.println();
            }
            //转换为稀疏数组保存
            //获取有效值的个数
            int sum = 0;
            for (int i = 0; i < 11; i++) {
                for (int j = 0; j < 11; j++) {
                    if (array1[i][j]!=0){
                        sum++;
                    }
                }
            }
            System.out.println("有效值的个数:"+sum);
            //2.创建一个稀疏数组的数组
            int[][]array2=new int[sum+1][3];
            array2[0][0]=11;
            array2[0][1]=11;
            array2[0][2]=sum;
            //遍历二维数组，将非零的值，存放稀疏数组中
            int count = 0;
            for (int i = 0; i < array1.length; i++) {
                for (int j = 0; j < array1[i].length; j++) {
                    if(array1[i][j]!=0){
                        count++;
                        array2[count][0]=i;
                        array2[count][1]=j;
                        array2[count][2]=array1[i][j];
    
                    }
                }
            }
            //输出稀疏数组
            System.out.println("稀疏数组");
            for (int i = 0; i < array2.length; i++) {
                System.out.println(array2[i][0]+"\t"
                +array2[i][1]+"\t"
                +array2[i][2]+"\t");
            }
            System.out.println("========================");
            System.out.println("还原");
            //1.读取稀疏数组
            int[][]array3 = new int[array2[0][0]][array2[0][1]];
            //2.给其中的元素还原它的值
            for (int i = 1; i < array2.length; i++) {
                array3[array2[i][0]][array2[i][1]]= array2[i][2];
            }
            //打印
            System.out.println("输出原始的数组");
            for (int[]ints:array3){
                for(int anInt:ints){
                    System.out.print(anInt+"t");
                }
                System.out.println();
            }
    
        }
    }
    

    ​

1. psvm 定义一个main方法
2. sout 打印
3. Ctrl + D 复制当前行，到下一行
4. Alt + Enter 自动解决问题
5. debug : F7下一步