JAVA基础

**一、**Java"白皮书"的关键术语
1、简单些
2、面向对象
3、分布式
4、健壮性
5、安全性
6、体系结构中立
7、可移植性
8、解释型
9、高性能
10、多线程
11、动态性

二、Java程序设计环境

 Java 目前有三个主要成员：
1）Java SE（Java Standard Edition）——用于工作站、PC 机的 Java 标准平台（标准版）；
2）Java EE（Java Enterprise Edition）——是可扩展的企业级 Java 应用平台（专业版）；
3）Java ME（Java Micro Editon）微缩版）；

1、下载JDK
网站：www.oracle.com/technetwork/java/javase/downloads
JDK（Java Development Kit）—Java 软件开发工具包，编写java程序的程序员使用的软件
JRE（Java Runtime Environment）——Java 运行时环境，包含 Java 虚拟机却不包含编译器

JDK 中比较常用的工具：
  Javac：Java 编译器，用于将 Java 源代码转换为字节码；
  Java：Java 解释器，直接从 Java 的类文件中执行 Java 应用程序字节码；
  Javadoc：根据 Java 源代码及说明语句生成 HTMl 文档；
  Jdb：Java 调试器，可以逐步执行程序，设置断点和检查变量；

三、Java基本语法**

1.Java的基本结构
*
1.1 建立一个类

【java所有的代码,都必须在一个类里面,必须先建一个类,注意文件名也必须和类名一致】

   public class 类名{
    代码要写在{}里面
 }

1.2 java的main方法

1.3编写Java程序时，应注意以下几点：

 大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。
      类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
    方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
  源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。（如果文件名和类名不相同则会导致编译错误）。
主方法入口：所有的Java 程序由public static void main(String []args)方法开始执行

1.4****输入语句

1.声明Scanner 变量
Scanner input = new Scanner(System.in);
2.在类名的上边,引入Scanner所在的位置
import java.util.Scanner;
3.使用
input.nextXXX();
获取用户输入的int的值
input.nextInt();
获取用户输入的double的值
input.nextDouble();
获取用户输入的float的值
input.nextFloat();
获取用户输入的String的值
input.next();

2、Java标识符

 对于Java标识符，有以下三点要求：

 1.标识符由字母、数字、_、$ 组成，不能以数字开头，不能用Java中的保留关键字
 2.标识符采用有意义的简单命名
 3.“ $”不要在代码中出现

3、Java变量

 public class Variable{
   static int allClicks=0;    // 类变量
   String s="hello world";  // 实例变量
 public void method(){
    int i =0;  // 局部变量 
 }
}

整性

数据类型	存储需求	取值范围
int	4个字节	-2147483648~2147483647(正好超过20亿)
short	2个字节	-32768~32767
long	8个字节	-9223372036854775808~92233720368547758007
byte	1个字节	-128~127

浮点型

数据类型	存储需求	取值范围
float	4个字节	大约3.40282347E+38F（有效位数为6~7位）
double	8个字节	大约179769313486231570E+308（有效位数为15位）

字符型

数据类型	存储需求
char	2个字节

布尔型

数据类型	取值范围
boolean	true 和 false

4、Java 运算符
4.1 算术运算符

数据类型	取值范围
+	加法
-	减法
*	乘法
/	除法
%	取余(求模)

取余例子:

用户输入一个4位数

分别声明4个变量来保存个,十,百,千位上的数字

通过取余数,来获取每个位置上的数字

打印输入的4位数

System.out.println("请输入四位数:");
Scanner input = new Scanner(System.in);
int sum = input.nextInt();
​
int ge,shi,bai,qian;

ge = sum % 10;
shi = sum / 10 % 10;
bai = sum / 100 % 10;
qian = sum / 1000;

System.out.println( ge + shi + bai + qian);

4.2 关系运算符

运算符	描述	例子
==	检查如果两个操作数的值是否相等，如果相等则条件为真	（A == B）为假
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真	(A != B) 为真
>	检查左操作数的值是否大于右操作数的值，如果是那么条件真	A> B）为假
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真	（A <B）为真
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真	（A> = B）为假
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真	（A <= B）为真

4.3 位运算符

运算符	描述	例子
＆	如果相对应位都是1，则结果为1，否则为0	（A＆B），得到12，即0000 1100
^	如果相对应位值相同，则结果为0，否则为1	（A ^ B）得到49，即 0011 0001
〜	按位取反运算符翻转操作数的每一位，即0变成1，1变成0	（〜A）得到-61，即1100 0011
<<	按位左移运算符。左操作数按位左移右操作数指定的位数	A << 2得到240，即 1111 0000
>>	按位右移运算符。左操作数按位右移右操作数指定的位数	A >> 2得到15即 1111
>>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充	A>>>2得到15即0000 1111

   |         如果相对应位都是 0，则结果为 0，否则为 1	      （A | B）得到61，即 0011 1101

4.4 逻辑运算符

运算符	描述	例子
&&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真	（A && B）为假
！	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false	（！（A && B）为真

| |	      称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真    	（A | | B）为真。

`

4.5 赋值运算符

运算符	描述	例子
=	简单的赋值运算符，将右操作数的值赋给左侧操作数	C = A + B将把A + B得到的值赋给C
+ =	加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数	C + = A等价于C = C + A
- =	减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数	C - = A等价于C = C - A
* =	乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数	C * = A等价于C = C * A
/ =	除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数	C / = A，C 与 A 同类型时等价于 C = C / A
（％）=	取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数	C％= A等价于C = C％A
<< =	左移位赋值运算符	C << = 2等价于C = C << 2
>> =	右移位赋值运算符	C >> = 2等价于C = C >> 2
＆=	按位与赋值运算符	C＆= 2等价于C = C＆2
^ =	按位异或赋值操作符	C ^ = 2等价于C = C ^ 2

| =                  	按位或赋值操作符	                              C | = 2等价于C = C | 2

5、Java 输入/输出
标准输入流

Scanner in = new Scanner(System.in) ;

6、Java 控制语句

6.1 循环语句

1.1 for循环
for（①初始化部分；②循环条件部分；④迭代部分）{
     ③循环体部分
}

1.2 while循环
①初始化部分
while
（②循环条件部分）{
③循环体部分
④迭代部分
}

1.3 do-whlie循环
①初始化部分
do{
③循环体部分
④迭代部分
}while（②循环条件部分；

6.2 条件语句

 if语句

6.3 switch-case 语句

switch(表达式){
case 常量1：
语句1；
//break;
case 常量N：
语句N；
//break；
default:
语句；
//break;
}

7、数组

一、维数组的使用：

（1）、声明

type var[]或type[] var：
例如：int a[];
int[]a1;
double b[];
String[] c;//引用类型变量数组

（2）、java语言中声明数组时不能指定其长度（数组中元素的数），例如：int a[5];//非法

（3）、动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行

int[] arr = new int[3];

（4）、静态初始化：在定义数组的同时就为数组元素分配数组元素分配空间并赋值。

int arr[] = new int[]{1,2,3};

二、维数组的使用

1.声明

格式1（动态初始化）：int arr = new int3;

格式2（动态初始化）：int arr = new int3;

格式3（静态初始化）：int arr = new int{{1,2,3},{1,2,3},{1,2,3}}

三、 冒泡排序

int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
       
        //冒泡排序(从小到大排)
        for(int i = 0;i < arr.length - 1;i++){//外层循环控制轮数   数组长度-1       
            for(int j = 0;j < arr.length - 1 - i;j++){//内层进行判断如果j+1>j的值就进行交换    
            内层循环次数=数组长度-1-外层循环的次数             
                if(arr[j] > arr[j + 1]){
                    int temp = arr[j];//temp中间变量，起到替换两个值时中间量的作用
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }            
            }            
        }

四、 算法排序

int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
int temp= 0;//中间变量，起到替换两个值时中间量的作用
        int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
        for (int i = 0; i < arr.length - 1; i++) {// 外层循环控制轮数 数组长度-1
            for (int j = i+1; j < arr.length; j++) {// 内层进行判断如果i>j的值就进行交换    
            循环次数=等于数组长度     内层循环的初始值等于外层循环+1
                if (arr[i] > arr[j ]) {
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + "\t");
        }

五、 选择排序

int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
        int temp= 0;
        for (int i = 0; i < arr.length; i++) {
            int k = i;//记录此时数值的下标位置
            for (int j = arr.length-1; j >i ; j--) {//从数组的最后一位开始循环      循环的初始值=数值长度-1
                if(arr[j]>arr[k]) {//进行比较，如果外层循环（数组前面的数）比内层循环（数组后面的数）小，
                    k = j;         //那么进入判断记录此时内层循环（数组后面的数）的下标，
                                   //此时k记录的就是内层循环（数组后面的数）比外层循环（数组前面的数）大的数的下标。
                }
            }
            //通过获取的比较后的数组下标进行交换
            temp = arr[i];
            arr[i] = arr[k];
            arr[k] = temp;
        }
        
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + "\t");
        }

六、 插入排序

int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};      
        int temp = 0;
        int j = 0;
        for(int i=0; i<arr.length; i++) {
          temp = arr[i];
​
          for(j=i; j>0 && temp<arr[j-1]; j--) {
              arr[j] = arr[j-1];
          }
​
          arr[j] = temp;
        }
​
        System.out.println("插入排序之后====");
        System.out.println(Arrays.toString(arr));

七、 java自动排序

int [] a=new int [100];
Arrays.sort(a);

8、Arrays工具类的使用

链接: https://blog.csdn.net/TL19970