java基础知识

1.JVM
Java虚拟机；加载.class字节码文件并运行.class字节码文件

JRE
Java运行环境；包含JVM和运行java所必需的java系统类库

JDK
Java开发工具包，包含JRE和开发java程序所必须的命令工具

说明：
运行java程序的最小环境为 JRE
开发java程序的最小环境为 JDK
三、eclipse
1.定义
IDE集成开发环境（带图形界面的功能强大的开发工具）

优点
IBM公司的、开源的、免费的，不需要安装，仅需解压即可

开发步骤
新建Java项目/工程-------------小区

新建Java包--------------------楼+单元

新建Java类--------------------房子

四、注释
1.解释性文本
单行注释： // 文字注释

多行注释： /*

文字注释

......

文字注释

*/

文档注释： /**  文档注释   */

2.其他注释
其他注释属于后期内容，后期定会填充

五、变量
1.声明-----------相当于在银行开个账户

 int a; //声明一个整型的变量，名为a

 int b,c,d; //声明三个整型的变量，名为b,c,d

2.初始化--------相当于给银行账户存钱

 int a = 250; //声明整型变量a并赋值为250

      int a;   //声明整型变量a

      a = 250; //给变量a赋值为250

3.使用-----------相当于使用银行账户里的钱

对变量的使用就是对它所存的那个数的使用  

   int a = 5;
 
     int b = a+10; //取出a的值5，加10后，再赋值给变量b
 
  System.out.println(b);   //输出变量b的值15
 
  System.out.println("b"); //输出b，双引号中的原样输出
 
     a = a+10; //取出a的值5，加10后，再赋值给a
 
  //在a本身基础之上增10
 
  System.out.println(a); //15
 
//变量在用之前必须声明并初始化
 
     //System.out.println(m); //编译错误，变量m未声明
 
  int m;
 
 //System.out.println(m); //编译错误，变量m未初始化

4.命名规则
只能包含字母、数字、_和$符，并且不能以数字开头

严格区分大小写

不能使用关键字

允许中文命名，但不建议，

建议"英文的见名知意"、"驼峰命名法"

六、八种数据基本类型
数据类型

占位

字节

范围

1

byte

8

1

-128~127

2

short

16

2

-32768~32767

3

char

16

2

0~65535

4

int

32

4

-2147483648~2147483647

5

double

64

8

无限大

6

float

32

4

无限大

7

long

64

8

-9223372036854775808~

9223372036854775807

8

boolean

8

1

True   false

七、数据类型之间的转换
byte short char 通常转换为int计算

1.自动类型转换
基本数据的自动类型转换只有7种数据类型，除了布尔型
基本原则：低级别可以转高级别
从左向右可以依次转换：byte-short-int-long-float-double
 char-int-long-float-double
运算时的自动转换条件：两种数据类型要兼容，目标类型大于原类型

当范围大的类型与范围小的类型进行运算时，结果会自动转成范围大的类型

2.强制类型转换
高级别转低级别时必须进行强制类型转换

　　是否进行强制类型转换取决于数据类型级别的高低，而不取决于数据类型的实际值

格式：(type)value， type是要强制类型转换后的数据类型

public class mainTest {
 
    public static void main(String[] args) {
 
        int pageSize = 3;
 
        long pageNo = 2;
 
        int num =  (int) ((pageNo-1)*pageSize);// 强制类型转换，long类型转换为int类型
 
        System.out.println(num);
 
        int test =  (int)(pageNo-1)*pageSize;
 
        System.out.println(test);
 
    }
 
}

八、运算符
1.算术运算符
+ , - , * , / , % , ++ , --

（1）使用规则：必须与变量一起使用
a++/++a/a--/--a

++/--表示变量里的值会自动+1/-1后存入变量里。

（2）使用情况分两种：
与变量单独使用时（既不与其他任何字符连用）

eg:a++

当自增/自减表达式参与其他运算时

符号在前，变量先自增/自减，然后把新值赋值给表达式。

符号在后，先把值赋值给表达式，变量再自增/自减。

（3）简化版：
符号在前，先运算再赋值。

符号在后，先赋值再运算。

2.关系运算符
> , < , >= , <=  ，== , != ， boolean

逻辑运算符
&& , || , !  boolean

逻辑运算符

逻辑功能

&(并且)

有false则false

|(或者)

有true则true。

!(非)

非false则true，非true则false。

^(异或)

相同为false，不同为true。

&&(短路与)

有false则false,若&&左边表达式或者值为false则右边不进行计算

||(短路或)

有true则true,若||左边表达式或者值为true则右边不进行计算

    2.赋值运算符

= , += , -= , *= , /= , %=

运算符

用法举例

等效的表达式

+=

a += b

a = a+b

-=

a -= b

a = a-b

*=

a *= b

a = a*b

/=

a /= b

a = a/b

%=

a %= b

a = a%b

  3.三目运算符

boolean?语句块1:语句块2

执行规则：  Boolean值为true 则执行 语句块1；

Boolean值为false 则执行 语句块2；

  4.字符串连接运算符

字符串连接用 + 来实现，“ + ”是算术运算符又是字符串拼接运算符，即 若同时出现则字符串连接前的运算符为算术运算符，字符串连接后的都为字符串连接运算符

Eg.

System.out.println(9 + 7 + "may" + 4 + 7);
输出结果为 ： 16may47

九、分支结构
1.if结构
语句：

if(boolean){
 
  语句块
 
}
执行过程：

若Boolean值为true，则执行语句块

若Boolean值为false，则不执行语句块

if...else结构
语句：

 if(boolean){
 
  语句块1
 
}else{
 
语句块2
 
}
执行过程：

若Boolean值为true，则执行语句块1

若Boolean值为false，则执行语句块2

      2.if...else if结构

语句：

if（boolean—1）{
 
语句块1
 
}elseif（boolean—2）{
 
语句块2
 
}elseif（boolean—3）{
 
语句块3
 
}else{
 
语句块4
 
}

执行过程:

判断boolean-1，结果为true则执行语句块1，若执行条件为false则

执行boolean-2，结果为true则执行语句块2，若执行条件为false则

执行boolean-3，结果为true则执行语句块3，若执行条件为false则

执行语句块4

      3.switch...case结构

优点：效率高、结构清晰

缺点：只能对整数来判断、相等

break：跳出switch

int num = 2；
 
switch （num）{         //byte，short，int，char，
 
//string（jdk 1.7后可以支持）
 
case 1：//if（num ==1）
 
System.out.println(1);
 
case 2：//以此为入口
 
System.out.println(2);
 
break；//跳出switch
 
case 3：//以此为入口
 
System.out.println(3);
 
default：//所有case都未匹配时在执行
 
System.out.println(3);
 
}

十、循环结构
1.while结构
  语句： 

  while（boolean){
 
   语句块
 
   }
  执行过程：

  判断boolean的值，若为true则执行语句块；

   判断boolean的值，若为true则执行语句块；

   判断boolean的值，若为true则执行语句块；

   如此反复，直到boolean的值为false时结束

do...while结构
语句：

do{
 
语句块
 
}while（boolean）
执行过程：

执行语句块，

判断boolean的值，若为true则执行语句块；

   判断boolean的值，若为true则执行语句块；

   判断boolean的值，若为true则执行语句块；

   如此反复，直到boolean的值为false时结束

      2.for循环结构

语句：

for（初始条件 1 ; 判断条件 2; 改变条件 3 ）{
 
循环体   4;
 
}
或

初始条件1;
 
for（;判断条件2;){
 
循环体4
 
改变条件3;
 
}
执行过程：（1 2 4 3 2  4  3  2）

执行初始条件1

执行判断条件2 若为true，则执行循环体4，在执行改变条件3；

执行判断条件2 若为true，则执行循环体4，在执行改变条件3：

......

执行判断条件2 若为true，则执行循环体4，在执行改变条件3：

执行判断条件2 若为false，则for循环结束

for（;;){//没有条件的循环是死循环

执行体

}

       3.三种结构最佳适用情况

先看循环是否与次数相关

若与次数相关-------for循环--------------打印机类型

若与次数无关，再看要素1与要素3是否相同

相同时-----do...while 语句循环-------猜数字游戏

不同时-----while语句循环

        4.小结：

1）顺序结构：从上到下逐行执行，每句必走

2）分支结构：有条件的执行某语句一次，并非每句都走

3）循环结构：有条件的执行某语句多次，并非每句都走

十一、嵌套结构
1.定义
循环中套循环， 一般多行多列时使用，外层控制行，内层控制列

执行规则
外层循环走一次，内层循环走所有次

     2.建议

嵌套层数越少越好，能有一层就不用两层，能用两层就不用三层

若业务必须通过三层以上的循环来解决，说明设计有问题

十二、数组
1.定义
数组也是一种数据类型（引用数据类型）

数组是相同数据类型元素的集合

2.声明
int[] arr = new int [10];
 
//声明整型数组arr，包含10个元素
 
//每个元素都是int类型，默认值为0
3.初始化
---初始化数组中的数据

int[]  arr = new int [4]; //0,0,0,0
 
int[]  arr = {1,4,5,8};//1,4,5,8
 
int[]  arr = new int []{1,4,5,8};//1,4,5,8
 
 
 
int[] arr;
 
arr = {1,4,5,8};//编译错误，此方式只能声明同时初始化
 
arr = new []{1,4,5,8};//正确
4.访问
----访问数组中的数据

（1）通过（数组名.length）可以获得数组的长度（元素的个数）

int [] arr = new int [5];
 
Systrem.out.println("arr.length");
（2）通过下标/索引来访问数组中的元素

  下表从0开始，最大到（数组长度-1）

int[]  arr = new int [3];
 
arr[0] = 100;//给arr第1个元素赋值为100；
 
arr[1] = 100;//给arr第1个元素赋值为200；
 
arr[2] = 100;//给arr第3个元素赋值为300；
 
arr[3] = 400;//运行时，会发生数组下标超出界限（越界）的异常
 
 
 
System.out.println (arr.length);//输出数组长度
 
System.out.println (arr[arr.length-1]);//输出arr中最后一个数组

5. 遍历
----从头到尾看

int[] arr = new int [10];
 
for (int i = 0;i <arr.length;i++){//遍历数组
 
arr[i] = 100;//给每个元素都赋值为100
 
arr[i] = (int)(Math.Random.()*100)//赋值100内的随机数
 
System,out.println(arr[i]);//输出每个元素
 
}
//将arr数组转换为字符串并输出

System.out println(Arrays.toString(arr));//简便输出基本数组
6.复制
方式1:（灵活性更好）

int[] a ={10,20,30,40,50};
 
int[] b =new int[6];
 
 
 
System.arraycopy(a, 1, b, 0, 4);
 
//System.arraycopy(src, srcPos, dest, destPos, length);
 
//a:源数组(src)
 
//1：源数组的起始下标(srcPos)
 
//b:目标数组(dest)
 
//0:目标数组的起始下标(destPos)
 
//4:要复制的元素个数(length)

注意：此方式容易溢出！编译出现错误

方式2：（灵活性差）

int[] a = {2,5,3,8,6,7};
 
int[] b = Arrays.copyOf(a, 6);
 
//int[] b = Arrays.copyOf(original, newLength)；
 
//a:源数组(original)
 
//b:目标数组
 
//6:目标数组的长度（元素个数）(newLength)
 
//--若目标数组长度大于源数组长度，则末尾补默认值0
 
//--若目标数组长度小于源数组长度，则从末尾截掉
 
 
 
a = Arrays.copyOf(a,a.length+1);//数组扩容

7.排序
常用的排序方法：冒泡排序、插入排序、快速排序---执行效率不算太高

冒泡排序---工作中永远不会写，但是一个常见面试题

排序分类：升序（从小到大）/降序（从大到小）

（1）Arrays.sort（arr）；//对arr进行升序排列

（2）升序排列：

for (int i = 0; i < arr.length; i++) {
 
Arrays.sort(arr);
 
System.out.print(arr[i]+"\t");
 
}
 降序排列：

for(int i=arr.length-1;i>=0;i--) {
 
Arrays.sort(arr);
 
System.out.print(arr[i]+"\t");
 
}
十三、方法
1.意义
1）封装一段特定的业务逻辑功能

2）方法尽可能独立，一个方法只干一件事

3）方法可以被反复调用多次

4）减少代码重复，有利于代码的复用；有利于团队的协作

2.定义
五要素：

修饰词  返回值类型   方法名（参数列表）{

方法体

}

1）修饰词：public  

2）返回值类型：方法可有返回值，也可没有返回值

无返回值时：返回值类型写成void

有返回值时：返回值类型写成特定的数据类型

  返回值有误判断：

方法执行完后

（1）若还需要用到方法中的某个数据-----有返回值

（2）若不再需要用到方法中的某个数据---无返回值

3）方法名：见明知义，驼峰命名

4）参数列表：方法可有参，也可无参

参数：  定义方法时的参数为 形参-----String name/int i...

调用方法时的参数为 实参-----int i=3/lisi/12

有参数：方法更加灵活

无参数：

5）方法体：

3.调用
1）无返回值：方法名（有参传参）

2）有返回值：若有返回值，则在的方法中必须通过return来返回数据

并且return后的书必须与返回值类型匹配

数据类型  变量 = 方法名（有参传参）

十四、关键字用法
1.scanner
Scanner接受用户输入的数据

1）在package下:

import java.util.Scanner;
2）在main中：

Scanner com = new Scanner(System.in);
3）在第二步之后：

int command = com.nextInt();
2.break与continue
 break：循环中看到break就跳出循环（在某种特殊条件下提前结束循环）

当多层嵌套时，只用于跳出一层循环

continue：跳过循环体中的剩余语句，进入下一次循环（不能出现在switch语句中）

3.Return
1）return值：

（1）结束方法的执行

（2）返回结果给调用方

--用在有返回值的方法中

2）return； ：

（1）结束方法的执行

（2）在某种特定条件下提前结束方法

4.水平制表符 \t
\t 表示制表符，相当于制表符

前面的输出内容位数为8的倍数，\t将输出8个空格

前面的输出内容位数不是8的倍数，\t将补足8位