java基础

标签：Java int 基础参数 chess 数组 java sparseArray

Java规范

Java 的编译过程

记事本写java 的步骤

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

	}
}

编写源代码：保存成类名.ava 保存文件编码默认ANSI格式可以显示中文
首字母大写
第二个首字母也要大写
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的命名规范

Java命名规范1
Java命名规范2

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

JavaDoc

二、流程控制

1.Scanner对象

2.顺序结构

3.选择结构

if单选择结构
if双选择结构
if多选择结构
嵌套的if结构
switch多选择结构

4.循环结构

while循环
do while循环
for循环
增强型for循环
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();
        }

标签：Java,int,基础,参数,chess,数组,java,sparseArray
From： https://www.cnblogs.com/ynxiyan/p/17030784.html