Java规范

Java 的编译过程

• 记事本写java 的步骤

public class 类名 {
public static void main(String[ ] args){
System.out.println("Hello,World");
 
	}
}

1. 编写源代码 ： 保存成 类名.ava 保存文件编码默认ANSI格式可以显示中文
2. 首字母大写
   第二个首字母也要大写
   2 ． 编译源文件 ： 把编写好的源文件通过javac 命令编译成 类名 .class 字节码文件 （ 二进制文件 ）
   3 ． 运行编译后的class文件 ：java 命令运行 类名

程序的三大结构： 顺序结构 、 选择结构 、循环结构
编写程序步骤：编写源程序 、编译源代码 、 运行编译后的代码
.class 字节码文件（ 二进制 ）
IDE（ 集成开发环境 ）
记事本 DOS 命令 ： javac 编译命令 java 命令运行.class 文件
Java 注释：单行注释// 多行注释 /* 开头 / 结尾 javaDOC 注释 /* */
顺序结构：代码是一行一行执行 ，有一个单等号（ 赋值运算符 ）时执行顺序是从右到左

Java 历史 ： 最先叫 Oak （ 橡树的英文 ） ， 1995 年 sun 公司推出 Java ，sun 公司 2009 年被 Oracle （ 甲骨文 ） 公司收购 ， Java 之父詹姆斯高斯林
Java 技术平台 ：
Java SE ： 标准版基础版
Java EE ： 企业版 java web
Java ME ： 移动端 Android 端嵌入端开发如 POS 机等
2.对象 （ 引用数据 ） 类型null

一、基础

1.标识符

• 关键字

  

• 标识符注意点

  

2.数据类型

• 八大基本类型

  1.成员变量

  

  2.成员变量 （ 属性 ） 的默认值

  byte 0
  short 0
  int 0
  long 0
  float 0.0
  double 0.0
  boolean false
  char ' \ u000' ' '
  

  3.2-3-2-1

  • 二个字符型

    byte字节型（0，1）

    char字符型 单个字符(支持ASCIII码、UNICODE码)

  • 三个整型

    short短整型

    int整型

    long长整型

  • 二个浮点型

    float单精度浮点型

    double双精度浮点型

  • 一个布尔型

    boolean 值 true/false 真/假

  除了八个基本数据类型 ， 其它的类型都叫做引用 （ 对象 ） 类型

• 拓展

  

  

  

  

3.类型转换

4.变量

在 JAVA 里 ， 看见首字母大写的就是类或（ 接囗 、 枚举 ）
看见单引号括起来的就是char类型 ，双引号括起来的就是字符串 ，看见全大写的就是常量 ，中括号括起来的是数组 ，小括号就是方法 ， 里面有参数就是带参方法 ，没参就是无参方法 ，大括号括起来的就叫代码块 ，尖括号括起来的叫泛型

数字中使用下划线
规则 1 ：JDK1.7 或以上
规则 2 ：只能用在数字之间 ，不能用在数字开头或结尾 ，
小数点前后也不行

5.变量作用域

6.常量

7.Java的命名规范

8.转义符

9.运算符

• 位运算符

  

• 逻辑运算符

  

• 

  

10.Java Math 类

Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。

Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。

• Number & Math 类方法

  下面的表中列出的是 Number & Math 类常用的一些方法：

  序号	方法与描述
  1	xxxValue() 将 Number 对象转换为xxx数据类型的值并返回。
  2	compareTo() 将number对象与参数比较。
  3	equals() 判断number对象是否与参数相等。
  4	valueOf() 返回一个 Number 对象指定的内置数据类型
  5	toString() 以字符串形式返回值。
  6	parseInt() 将字符串解析为int类型。
  7	abs() 返回参数的绝对值。
  8	ceil() 返回大于等于( >= )给定参数的的最小整数，类型为双精度浮点型。
  9	floor() 返回小于等于（<=）给定参数的最大整数 。
  10	rint() 返回与参数最接近的整数。返回类型为double。
  11	round() 它表示四舍五入，算法为 Math.floor(x+0.5)，即将原来的数字加上 0.5 后再向下取整，所以，Math.round(11.5) 的结果为12，Math.round(-11.5) 的结果为-11。
  12	min() 返回两个参数中的最小值。
  13	max() 返回两个参数中的最大值。
  14	exp() 返回自然数底数e的参数次方。
  15	log() 返回参数的自然数底数的对数值。
  16	pow() 返回第一个参数的第二个参数次方。
  17	sqrt() 求参数的算术平方根。
  18	sin() 求指定double类型参数的正弦值。
  19	cos() 求指定double类型参数的余弦值。
  20	tan() 求指定double类型参数的正切值。
  21	asin() 求指定double类型参数的反正弦值。
  22	acos() 求指定double类型参数的反余弦值。
  23	atan() 求指定double类型参数的反正切值。
  24	atan2() 将笛卡尔坐标转换为极坐标，并返回极坐标的角度值。
  25	toDegrees() 将参数转化为角度。
  26	toRadians() 将角度转换为弧度。
  27	random() 返回一个随机数。

11.包机制

12.JavaDoc

二、流程控制

1.Scanner对象

2.顺序结构

3.选择结构

• if单选择结构

  

• if双选择结构

  

• if多选择结构

  

• 嵌套的if结构

  

• switch多选择结构

  

4.循环结构

• while循环

  

• do while循环

  

• for循环

  

  

• 增强型for循环

  

• foreach

  for的简化形式,与for的区别仅仅是隐藏了循环条件,不需要使用下标,适合在不关心下标,需要把数组或集合全部遍历的情况 0dk1.5 或以上 ）
  foreach迭代不会数组越界,适合循环输出所有的元素
  foreach会默认全部输出数组或列表对象
  迭代对象可以是数组或集合
  for（ 数据类型   迭代元素（ 元素名or对象名 ） ：迭代对象（ 数组或集合 ）） {}
  

• break&continue&goto

  

三、方法

1.什么是方法

2.方法的定义

3.方法调用

4.方法重载

5.命令行传参

6.可变参数

7.递归

• 示例

  public static void main(String[] args) {
      //递归（小计算可用，大计算禁用！！！），求阶乘（2！=2*1 3！=3*2*1）
      System.out.println(factorial(5));
  }
   
  /**
   * 求阶乘
   *
   * @param num
   * @return
   */
  public static int factorial(int num) {
      if (num == 1) {
          return num;
      } else {
          return num * factorial(num - 1);
      }
  }
  

• 原理

  

四、数组

1.数组的定义

2.数组声明创建

3.内存分析

3.三种初始化

4.数组的四个基本特点

5.数组边界

6.数组的使用

五、多维数组

• 数组结构

  

1.二维数组

• 二维数组结构

  

六、Arrays类

七、冒泡排序

• 原理

  交换前：

  交换后：

  

• 优化

  

八、稀疏数组

1.稀疏数组介绍

//1. 创建一个二维数组 11*11
    // 0：没有棋子（数组默认值）
    // 1：黑子
    // 2：白子
    static String chessman = "0";
 
    public static void main(String[] args) {
        int[][] chess = new int[11][11]; //棋盘数据
        chess[1][2] = 1;
        chess[2][3] = 2;
        chess[6][6] = 2;
        chess[9][9] = 1;
        chess[8][5] = 1;
        chess[4][10] = 2;
        System.out.println("棋盘：");
        print(chess);
        //保存棋盘数据成稀疏数组
        int valid = 0; //棋子数
        for (int i = 0; i < chess.length; i++) {
            for (int j = 0; j < chess.length; j++) {
                if (chess[i][j] != 0) {
                    valid++;
                }
            }
        }
        int[][] sparseArray = new int[valid + 1][3]; //稀疏数组
        sparseArray[0][0] = 11;
        sparseArray[0][1] = 11;
        sparseArray[0][2] = valid;
        int value = 0; //棋子坐标
        for (int i = 0; i < chess.length; i++) {
            for (int j = 0; j < chess.length; j++) {
                if (chess[i][j] != 0) {
                    value++;
                    sparseArray[value][0] = i;
                    sparseArray[value][1] = j;
                    sparseArray[value][2] = chess[i][j];
                }
            }
        }
        System.out.println("棋盘数据：");
        System.out.println("\t\t行\t列\t值\\棋子");
        for (int i = 0; i < sparseArray.length; i++) {
            if (i == 0) {
                System.out.println("棋盘总览：" + sparseArray[i][0] + "\t" + sparseArray[i][1] + "\t" + sparseArray[i][2]);
            } else {
                if (sparseArray[i][2] == 1) {
                    chessman = "黑";
                }
                if (sparseArray[i][2] == 2) {
                    chessman = "白";
                }
                System.out.println("\t\t" + (sparseArray[i][0] + 1) + "\t" + (sparseArray[i][1] + 1) + "\t" + chessman);
                chessman = "0";
            }
        }
        //还原
        int[][] restore = new int[sparseArray[0][0]][sparseArray[0][1]];  //还原数据组
        for (int i = 1; i < sparseArray.length; i++) {
            restore[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        System.out.println("棋盘还原：");
        print(restore);
    }
 
    /**
     * 棋盘输出
     *
     * @param array
     */
    public static void print(int[][] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] == 1) {
                    chessman = "黑";
                }
                if (array[i][j] == 2) {
                    chessman = "白";
                }
                System.out.print(chessman + "\t");
                chessman = "0";
            }
            System.out.println();
        }