JAVA基础入门一

---

1. Java基础
2. 计算机概述
   1. 计算机组成
      1. 硬件

• 硬件是电器元件，比如：CPU，主板，显卡
  1. 1. 软件
• 软件用于驱使硬件如何去工作
• 分类

• 系统软件

• 直接和硬件交互的软件，通常指windows，linux等操作系统

• 应用软件

• 运行在系统软件中，完成特定功能的软件

• 分类

• 产品软件

• 需求由软件公司制定，用户无条件接受软件功能，产品软件适合很多公司使用，通用性强，但无法定制一些公司特殊需求

• 项目软件

• 需求由客户提出，根据客户的需求，制作软件功能，项目软件是根据客户工作流程制定，没有通用性，但是可以定制公司特殊需求

• 1. 程序
     1. 程序通常指完成某些事务的一种既定方式和过程
     2. 在计算机中，可以被计算机连续执行的指令集合称为计算机程序
  2. 计算机进制
     1. 二进制
     2. 八进制
     3. 十六进制
• 如果余数大于9，以ABCDEF表示10到15
  1. 计算机语言
     1. 开发者通过计算机语言进行软件编写的，通过计算机语言，达到人机交互目的
     2. 分类
• 机器语言

• 全部由0和1组成，可以被硬件直接识别并直接运行，但是，阅读性和可维护性极差

• 汇编语言

• 以我们的助记符和一大段二进制码进行关联，以助记符来描述程序逻辑，执行时，需要将助记符还原成二进码，交由硬件执行

• 高级语言

• 面向操作系统编程，由操作系统管理内存和磁盘，开发者可以将重点放在逻辑现实上，而不是内存和磁盘管理上

• 翻译

• 操作系统并不能直接接受和执行用高级语言编写的源程序，源程序在输入操作系统时，通过“翻译程序”翻译成能被操作系统识别的二进制码，才能正确被操作系统识别

• 分类

• 编译

• 翻译源代码之后的文件，能被操作系统直接识别，直接运行

• 优点：执行速度快，缺点：不能跨平台使用，有安全性问题

• 解释

• 翻译源代码之后的文件，必须借助第三方应用程序，解释成能被操作系统识别和执行的二进制码

• 由第三方应用程序的参与，执行效率不如编译语言，但是可以通过更换第三方应用程序的解释器，让同一个应用程序可以在不同系统下运行，达到跨平台效果，同时可以在第三方应用程序中加入安全性处理，保证即使程序有BUG，也不会影响操作系统的的运行

• 1. 算法
     1. 解决问题的步骤和方法
     2. 特点
• 有穷性：一个算法必须执行有限个操作步骤后终止
• 确定性：算法中每一步含义必须是确切的，不可出现任何二义性
• 有效性：算法中的每一步操作都应该有效执行，一个不可执行的操作是无效的
• 有零个或多个输入：这里的输入指在算法开始之前所需要的初始数据
• 一个或多个输出：所谓输出是指得到算法执行的结果，在一个完整的算法中至少会有一个输出，如果没有结果输出，那么它将变得毫无意义

1. Java语法基础
   1. Java的特点
      1. 简单
      2. 面向对象
      3. 跨平台
      4. 健壮性和安全性
      5. 多线程
      6. 垃圾回收
   2. Java语言的分类
      1. JavaSE:标准版（是企业版和微型版的基础）
      2. JavaEE:企业版
      3. JavaME:微型版
   3. JDK和JRE（jdk包含jre）
      1. JDK:称为Java开发工具集，包括编译环境，运行环境，调试环境，基础类库
      2. JRE:称为Java运行环境，包括虚拟机，核心类库，以及链接文件
   4. dos系统常用命令
      1. cd\    进入当前盘符根目录
      2. 盘符名：   进入该盘符，比如：D：表示进入D盘
      3. cd  目录名   进入该盘符指定目录
   5. JDK环境变量
      1. 由于编译java源文件时，需要使用JDK安装目录中bin目录下的javac.exe文件。但是，如果每次都将源文件放在JDK/bin下，才能进行编译和运行，就很麻烦。为了在任何目录下。都能使用JDK编译和运行环境，所以需要配置环境变量。在环境变量，指定javac.exe文件所在的目录。这样，这样在其他目录中，如果没有javac命令，就会查找环境变量指定的路径。
      2. 配置步骤

• 右键单击我的电脑---属性--高级系统设置---选中高级高级选项卡---单击“环境变量”---在系统变量中单击新建--变量名书写为“JAVA_HOME"变量值书写为JDK安装目录---选中”path“单击编辑--增加%JAVA_HOME%\bin
  1. 第一个java程序
     1. 编写源文件源文件必须以*.java为后缀
• import javax.swing.*;
  
     class One{
        public static void main(String[] args){
     System.out.println("***println是自动换行**");
        
        //弹出输入框，用name接收用户输入的内容
        String name = JOptionPane.showInputDialog(null,"请输入名字：");
      //弹出消息对话框，显示内容
           JOptionPane.showMessageDialog(null,"您好,"+name);
        
         }
  
  }
  1. 1. 编写源文件时，必须定义类，在类中定义main方法，这是程序的入口点
     2. 如何编译
• javac 文件名.java
• 一个文件中，可以定义多个类，编译后，每个类都会生成class文件
  1. 1. 运行
• java 类名
  1. 1. 如果一个类声明为public,要求文件名与类名必须一致，否则，无法通过编译
  2. 虚拟机工作流程
     1. 编程源文件”*.java-----通过javac,将源文件编译成*.class---类加载----字节码校验---解释器----操作系统“
     2. 类加载的含义，虚拟机在执行类的内容之前，需要读取该类内容，开发者自定义的类中，可能会用到核心类库中的类，也可能用到第三方类库，所以，加载类时，不仅需要加载自定义类，而且核心类库和第三方类库都应该加载
     3. 加载顺序
• 先加载基础类库和核心类库，在加载第三方类库，最后加载开发者自定义类库
  1. 标识符
     1. 凡是可以命名的地方都叫标识符，通常使用标识符命名类，方法，变量等
     2. 标识符命名规则
• 必须以字母，数字，下划线，$组成
• 不能以数字开头
• 区分大小写
  1. 1. 命名规范
• 1.见名知意
• 2.类名以大写字母开始，采用驼峰命名法
• 3.方法名，变量名以小写字母开始，采用驼峰命名法
• 4.常量字母全部大小
  1. 1. 分类
• 1.系统标识符

• Java语言内置标识符，具有特殊意义

• 2.用户标识符

• 开发者自定义的类名，方法名，变量名等，注意用户标识符不能与系统标识符同名

• 1. 注释
     1. 注释是编译程序中，给一段代码说明性文字，注释对程序运行没有影响，，编译自动丢弃，其主要作用是增加代码可阅读性
     2. 分类
• //  ：单行注释
• /* */  :多行注释
• /**   */：文档注释
  1. 变量
     1. 变量是一个命名的内存空间，空间的内容会随着业务需要发生变化，通过用新数据替换老数据，达到内存空间重用的目的
     2. 变量三要素
• 1.数据类型
• 2.变量名
• 3.变量值
  1. 1. 分类
• 基本数据类型

• 整型

• byte:字节型  占1个字节 取值-128-127

• 一个字节占8位二进制码，1k=1024字节，1M=1024k,1G=1024M,1T=1024G

• short:短整型 占2字节

• int ：整型 占4字节

• long:长整型 占8字节

• 浮点型

• float:单精度浮点型占4个字节

• double:双精度浮点型占8字节

• 字符型

• char:占2个字节

• 字符型以整型方式存放，采用unicode编码，允许存放一个中文字,一个字符型数据中只能存放一个字符

• ’A‘--65  ’a'--97

• 字符数据可以做算法运算，运算时，将字符串ASC码进行运算

• 布尔型

• boolean:

• 取值只有true和false,表示条件是否成立

• 将字符串转化为int

• int a= Integer.parseInt(s);

• 将字符串转化为double

• double a = Double.parseDouble(s);

• 引用数据类型
  1. 类型转换
     1. 自动类型转换
• 自动类型转换，发生不同类型数据之间进行运算时，小类型数据自动转换为大类型数据
• 浮点常量默认为double，不能直接赋给float,   float=3.5f;
• 整型和整型运算，结果至少是int，无论是byte+byte,short+short,byte+short结果都是Int类型
• float类型容量大于long类型
  1. 1. 强制类型转换
• 一般发生在大类型转化为小类型，可能会损失精度
• 语法

• int k=(int)3.5;

• boolean不能转化为任何类型
  1. 1. 注意：变量没有赋值时，是不能使用的
  2. 常量
     1. 常量也是内存中命名的内存空间，空间的内容在运行期间不能发生变化
     2. 分类
• 字面常量

• 8----整型常量

• ‘A’----字符常量

• ”abc“----字符串常量

• 符号常量

• final int PRICE=5;

• 定义符号常量的意义：

• 1.可以在运算时，引入业务名称

• 2.可做到一改全改

1. 运算符
   1. 算术运算符：+，-，*，/，%       
      1.  %表示取模运算，把两个数相除取余数
      2. ++运算符

• 后置++，先运算，运算完成后，再将变量加一

•  int y = x++;//y=x,x=x+1

• 前置++，先将变量加一，然后再做运算

•  int z = ++x;//x=x+1,z=x

• 1. 关系运算符：>.>=,<,<=,==,!=
     1. ==比较两个数是否相等，如果相等满足条件
     2. ！=比较两个数是否相等，如果不相等满足条件
     3. 关系运算符，计算的结果是boolean值
     4. =和==的区别
• =是赋值语句，将等号右边的内容赋值给左边的变量
• ==是比较运算符，比较两个数是否相等，结果是boolean值
  1. 逻辑运算符：&&,,!
     1. 逻辑运算符，操作数必须是Boolean值
     2. &&并且表示两个条件都满足，结果才为true,有一个条件不满足，为false
• &&为短路运算符，当第一个条件为false时，不在执行第二个条件判断
  1. 1. 表示两个条件满足，结果都为true,只有两条件都不满足，为false
     2. !,非运算符，表示将true变为false,将false变为true,
  2. 三目运算符
     1. c？a：b
• ?之前c，为boolean表达式，表达式true时，将a的值返回；为false时，将b返回
  1. 扩展赋值运算符
     1. +=，-=，*=，/=
     2.    int y=8;
                y+=1.2;//y=(int)(y+1.2);结果为9

1. 1. 运算符优先级由高到低
      1. 括号，点，分号
                 * 一元运算符（操作数只有一个）：++,--,!,(类型强转)
                 * 算术运算符：+，-，*，/，%
                 * 关系运算符：>,<,>=,<=,==,!=
                 * 逻辑运算符：&&,<w:br/>        * 赋值运算符：=,+=,-=,*=,/=
      2. 算术运算符中，*，/，%优先级高于+，-,逻辑运算符中，&&高于
      3. 后置++和--优先级比赋值运算符还低
2. 选择结构
   1. 单分支
      1. 当条件满足，执行某个操作

• if(条件){执行语句}
  1. 双分支
     1. 当条件满足，执行某个操作，不满足执行另一个操作
• if（条件）{执行语句}else{执行语句}
  1. 1. 注意，else必须与if连用
  2. 多分支
     1. 当条件满足，执行某个操作，如果不满足，继续判断第二个条件是否满足...
• if（条件）{执行语句}else if{执行语句}else{执行语句}
  1. if.....else if    f和多个if的区别
     1. if...else if是一条多分支语句，只执行其中一个分支，，当一个分支满足时，执行该分支，，其余的分支不执行
     2. 多个if是多条单分支语句，每个if条件都会判断，只要满足都会执行
  2. switch
     1. switch是一种多分支语句，功能和if...else类似，相比if..else而言，switch语句结构更加清晰，但是，switch只能对表达式的结果做常量判断，不能象if一样判断范围
     2. 语法
• switch (x){
              case 1:
                  System.out.println("x=1");
                  break;
         .......
              default:
                  System.out.println("都不匹配");
                  break;
          }
  1. 1. 执行顺序
• 从第一个匹配表达式的case块执行,顺序执行，遇到第一个break，跳出switch判断
  1. 1. switch用于判断的表达式，取值必须为byte,short,int,char,String(JDK1.8)

1. 循环结构
   1. 在程序中，需要反复执行某个动作，直到循环条件不满足为止
   2. 分类
      1. while循环

• int a=1;
  //        //小和尚
  //        int b=99;
  //        while (a*3+b/3!=100){
  //            a++;
  //            b--;
  //        }
  //        System.out.println("大和尚"+a+"个，小和尚"+b+"个");
  1. 1. for循环
• int sum= 0;
  //        for (int i= 0;i<=100;i++){
  //            sum +=i;
  //        }
  //        System.out.println(sum);
• for中的三段都可以省略，但必须由两个分号

•  //初始化
        int i = 0;
        for (;;){
            if (i<=10){//条件判断满足，执行循环
                //循环体
                System.out.println(i);
            }else {
                //条件不满足，退出循环体
                break;
            }
            //变量变更
            i++;
        }

• 1. 1. do...while循环
• int x = 1;
          do {
              System.out.println(x);
          }while (x>100);
  1. while和for，都是先做条件判断，当满足条件时，执行循环，所以，，while和for循环，循环体有可能一次都不执行。                                                            
      do..while循环，是先执行循环体，再进行判断，所以，do..while循环，至少执行一次
  2. break
     1. 提前结束当前循环
  3. continue
     1. 结束本次循环，进入下一次循环
  4. 嵌套循环
     1. 在一个循环中，再写一个循环，称为嵌套循环，执行一次外循环，会完成整个内循环的执行，循环次数：外循环次数*内循环次数
     2. 语法
•  //99乘法表
          for (int i = 1; i <= 9; i++) {
  
              for (int j = 1; j <= 9; j++) {
                  System.out.print(i + "*" + j + "=" + i * j + " ");
              }
              System.out.println();
          }

1. 数组
   1. 数组是一段连续的内存空间，使用数组可以减少CPU搜索内存中变量的时间
   2. 特点
      1. 1.数组是一段连续内存空间，通过下标查找数组元素，下标从0开始，最大下标为长度-1
      2. 2.数组变量中，存放的是连续空间的首地址，属于引用数据类型
      3. 3.数组元素都是变量，变量的类型是声明数组的数据类型
      4. 4.数组元素创建后，每个元素都会初始化。
         int----0    double---0.0    引用类型---null
      5. 5.数组创建后，长度不能变化
   3. 数组定义
      1. 创建长度为5的数组,用arry存放数组首地址
                 int[] array = new int[5];
                 //将下标为1的元素赋值为5
                 array[1] = 5;
                 将下标为0的元素赋值为5
                 array[0] = 6;
         一个一个的赋值
      2. 创建具有初始数据的数组，数组长度由初始数据个数决定
         //        int[] array={1,2,3,4,5};
      3. 该方式和第二种定义数组的方式类似，也是定义数组时，完成数组元素的初始化，数组长度由初始数据个数决定
          int[] array =new int[]{1,2,3,4};
                 array = new int[]{1,2};
         array = {1,2,3}；这是不允许的
   4. 如果在访问数组元素时引用了非法下标（下标为负数，或大于或等于数组长度），就会抛出java.lang.ArrayIndexOutOfBoundsException
      数组下标越界异常
   5. 字符串和字符数组的相互转换
      1. 字符串转为字符数组

•   String s = "aasdas";
          //得到字符串对应的数组
          char[] charArray = s.toCharArray();
  1. 1. 字符数组转为字符串
• //将加密后的字符数组，变为字符串
  char[] charArray={"a","b","c"};
          String newStr = new String(charArray);
  1. main方法参数
     1. 在执行java类时，java 类名  aa bb cc
     2. aa,bb,cc就会做为mian方法参数String数组的元素存在
  2. 可变长数组
     1. 可变长数组只能做为方法的参数存在，表示在对可变长数组赋值时，可以传递任意个数的参数，这些参数会做为可变长数组的元素
     2. 调用方法
•  test(new String[]{"awe","wer","aewt"});
•   test("asef","fAFE","AF");
  1. 1. 可变长数组只能是方法的最后一个参数
  2. 二维数组
     1. 二维数组可以看做多个一维数组进行叠加，一维数组可以看做一条线，二维数组可以看做是一个表格，通过横坐标加纵坐标访问数组元素
     2. 定义
•  //定义两行三列的二维数组
          int[][] array = new int[2][3];
          //利用横下标+纵下标访问
          array[0][1] = 2;第一个[]代表第几行
          array[1][0] = 3;
          for (int i=0;i<2;i++){
              for (int j=0;j<3;j++){
                  System.out.print(array[i][j]+" ");
              }
              System.out.println();
          }
  1. 1. 二维数组长度为横坐标元素个数，new int[2][3]的长度为2
     2. 二维数组可以看做多个一维数组，每个一维数组长度可以不一致
•   int[][] array={{1,2,3},{2,3},{4,5,6,7,8}};
          for (int i=0;i<array.length;i++){
              for (int j=0;j<array[i].length;j++){
                  System.out.print(array[i][j]+" ");
              }
              System.out.println();
          }

1. 方法
   1. 计算机编程时常常将问题划分成称为“方法”模块，每个方法实现一项非常专一的功能，然后就可以根据所书写的方法构建程序
   2. 方法作用
      1. 1.分而治之
      2. 2.代码的复用
   3. 方法执行顺序
      1. 在调用方法时，执行方法中的内容，执行完毕后，回到调用方法处
   4. 方法的形参和实参
      1. 方法通过形参增加代码灵活性和通用性
      2. 形参是方法中的局部变量，其作用是接受实参的值
      3. 实参就是在调用方法时，如何给形参变量赋值，实参可以是变量，可以是常量，而形参只能是变量
      4. 形参和实参之间，要保证：类型一致，个数一致，顺序一致
   5. 变量作用域
      1. 变量的作用域指，该变量在什么范围内能够使用，也叫变量的作用范围
      2. 变量的有效作用范围，定义该变量{}以内
   6. 方法的返回类型和返回值
      1. 方法的返回类型，是指执行该方法后，能得到什么样的数据，一旦一个方法有返回类型，那么在任何时候都必须 有值返回，如果该方法没有返回类型，以void表示
      2. 方法返回值，表示执行该方法后，返回具体的值，在方法中，用return关键字，结束方法，并返回方法的返回值
         语法：return 返回值
         如果该方法声明为void,那么，return不能跟返回值
   7. return和break区别
      1. 1.break只能在循环语句和switch判断中使用，而return可以在方法的任何地方使用
      2. 2.break表示结束循环或switch判断，循环和switch判断结束后，继续执行后面的代码，而return是结束方法的执行，return以后，该方法中其余的代码不再执行
   8. 全局变量
      1. 在方法外，类里面定义的变量称为全局变量，全局变量在每个方法中都可以使用，每个方法共享全局变量
      2. 语法

•   public class Test{
          public static int x=2;
          .....
      }
  1. 递归
     1. 递归是一种特殊的循环，在方法中，再调用本方法，，使用递归时，需要注意，必须在有限步骤内，停止递归的调用，否则就是死循环
•  String isContinue=JOptionPane.showInputDialog(null,"是否继续y/n?");
           if (isContinue.equalsIgnoreCase("y")){//忽略大小写比较是否相等
               addEmployess();
           }
  1. 方法重载
     1. 方法重载发生在同一个类中，两个方法的方法名相同，参数列表不同（参数类型，参数个数，参数顺序），在调用方法时，通过实参来决定调用那个重载方法
     2. 方法重载，方法名和方法参数的类型会参与编译，而方法参数的名称和方法返回类型不会参与编译，所以，方法重载和方法返回类型，以及方法参数名无关
     3.     public static void look(){
                System.out.println("看");
            }
            public static void look(String s){
                System.out.println("看动漫"+s);
            }
            public static int look(String s){//不是重载方法，和look(String s)都编译成look_String,编译器无法区分
                
            }