【无标题】JAVA基础2.0

 

1.定义

1.定义

目录

一、java开发环境

二、名词解释

1.JVM

三、eclipse

1.定义

四、注释

1.解释性文本

2.其他注释

五、变量

4.命名规则

六、八种数据基本类型

七、数据类型之间的转换

1.自动类型转换

八、运算符

1.算术运算符

（2）使用情况分两种：

（3）简化版：

2.关系运算符

九、分支结构

1.if结构

十、循环结构

1.while结构

十一、嵌套结构

十二、数组

2.声明

3.初始化

十三、方法

1.意义

2.定义

3.调用

十四、关键字用法

1.scanner

4.水平制表符 \t

---

 

一、java开发环境

1. 编译运行过程（常见面试题）

1. 编译期：

将.java源文件交给编译器编译成.class字节码文件的过程

（2）运行期：

把编译后的.class字节码文件经过JVM加载并运行.class字节码文件

1. 配置环境变量

windows 10系统下配置JDK环境变量：
      （1）.安装JDK，安装过程中可以自定义安装目录等信息，例如我们选择安装目录为D:/java/jdk1.8.0_08；

（2）.安装完成后，右击“我的电脑”，点击“属性”；

（3）.选择“高级系统设置”选项卡，选择“高级”栏，点击“环境变量”；

（4）.在“系统变量”中，设置3项属性，JAVA_HOME     PATH     CLASSPATH

若已存在则点击“编辑”，不存在则点击“新建”；

（5）.JAVA_HOME指明JDK安装路径，例如刚刚安装时所选择的路径D:/java/jdk1.8.0_08，此路径下包括lib，bin，jre等文件夹；

Path使得系统可以在任何路径下识别java命令，设为： %JAVA_HOME%/bin;

创建 CLASSPATH变量

CLASSPATH为java加载类(class or lib)路径，只有类在classpath中，java命令才能识别，设为： .;%JAVA_HOME%/lib ；

（6）.“开始”－>;“运行”（win10系统下 win+R键 回车），键入“cmd”；

（7）.键入命令“javac”，“java”，“java -version”几个命令，出现画面，说明环境变量配置成功即环境变量配置成功；

1. java开发环境特点

跨平台的：软件可以不受计算机硬件和操作系统的约束而在任意计算机环境下正常运行；

　面向对象：指以对象为基本粒度，其下包含属性和方法；

　安全性：可以分为四个层面，即语言级安全性、编译时安全性、运行时安全性、可执行代码安全性；

多线程是指允许一个应用程序同时存在两个或两个以上的线程，用于支持事务并发和多任务处理；

一次编程到处使用：Java源代码的书写不拘泥于特定的环境，可以用记事本、文本编辑器等编辑软件来实现，然后将源文件进行编译，编译通过后可直接运行

二、名词解释

1.JVM

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

1. JRE

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

1. JDK

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

1. 说明：

1. 运行java程序的最小环境为 JRE
2. 开发java程序的最小环境为 JDK

三、eclipse

1.定义

IDE集成开发环境（带图形界面的功能强大的开发工具）

1. 优点

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

1. 开发步骤

新建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.使用-----------相当于使用银行账户里的钱

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

1.    int a = 5;

2.  

3.      int b = a+10; //取出a的值5，加10后，再赋值给变量b

4.  

5.   System.out.println(b);   //输出变量b的值15

6.  

7.   System.out.println("b"); //输出b，双引号中的原样输出

8.  

9.      a = a+10; //取出a的值5，加10后，再赋值给a

10.  

11.   //在a本身基础之上增10

12.  

13.   System.out.println(a); //15

14.  

15. //变量在用之前必须声明并初始化

16.  

17.      //System.out.println(m); //编译错误，变量m未声明

18.  

19.   int m;

20.  

21.  //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是要强制类型转换后的数据类型

1. public class mainTest {

2.  

3.     public static void main(String[] args) {

4.  

5.         int pageSize = 3;

6.  

7.         long pageNo = 2;

8.  

9.         int num =  (int) ((pageNo-1)*pageSize);// 强制类型转换，long类型转换为int类型

10.  

11.         System.out.println(num);

12.  

13.         int test =  (int)(pageNo-1)*pageSize;

14.  

15.         System.out.println(test);

16.  

17.     }

18.  

19. }

八、运算符

1.算术运算符

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

（1）使用规则：必须与变量一起使用

a++/++a/a--/--a

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

（2）使用情况分两种：

与变量单独使用时（既不与其他任何字符连用）

eg:a++

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

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

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

（3）简化版：

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

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

2.关系运算符

> , < , >= , <=  ，== , != ， boolean

1. 逻辑运算符

&& , || , !  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结构

语句：

1. if(boolean){

2.  

3.   语句块

4.  

5. }

执行过程：

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

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

1. if...else结构

语句：

1. if(boolean){

2.  

3.   语句块1

4.  

5. }else{

6.  

7. 语句块2

8.  

9. }

执行过程：

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

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

      2.if...else if结构

语句：

1. if（boolean—1）{

2.  

3. 语句块1

4.  

5. }elseif（boolean—2）{

6.  

7. 语句块2

8.  

9. }elseif（boolean—3）{

10.  

11. 语句块3

12.  

13. }else{

14.  

15. 语句块4

16.  

17. }

执行过程:

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

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

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

执行语句块4

      3.switch...case结构

优点：效率高、结构清晰

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

break：跳出switch

1. int num = 2；

2.  

3. switch （num）{         //byte，short，int，char，

4.  

5. //string（jdk 1.7后可以支持）

6.  

7. case 1：//if（num ==1）

8.  

9. System.out.println(1);

10.  

11. case 2：//以此为入口

12.  

13. System.out.println(2);

14.  

15. break；//跳出switch

16.  

17. case 3：//以此为入口

18.  

19. System.out.println(3);

20.  

21. default：//所有case都未匹配时在执行

22.  

23. System.out.println(3);

24.  

25. }

十、循环结构

1.while结构

  语句： 

1.   while（boolean){

2.  

3.    语句块

4.  

5.    }

  执行过程：

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

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

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

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

1. do...while结构

语句：

1. do{

2.  

3. 语句块

4.  

5. }while（boolean）

执行过程：

执行语句块，

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

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

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

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

      2.for循环结构

语句：

1. for（初始条件 1 ; 判断条件 2; 改变条件 3 ）{

2.  

3. 循环体   4;

4.  

5. }

 

或

1. 初始条件1;

2.  

3. for（;判断条件2;){

4.  

5. 循环体4

6.  

7. 改变条件3;

8.  

9. }

 

执行过程：（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.定义

循环中套循环， 一般多行多列时使用，外层控制行，内层控制列

1. 执行规则

外层循环走一次，内层循环走所有次

     2.建议

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

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

十二、数组

1.定义

数组也是一种数据类型（引用数据类型）

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

2.声明

1. int[] arr = new int [10];

2.  

3. //声明整型数组arr，包含10个元素

4.  

5. //每个元素都是int类型，默认值为0

3.初始化

---初始化数组中的数据

1. int[]  arr = new int [4]; //0,0,0,0

2.  

3. int[]  arr = {1,4,5,8};//1,4,5,8

4.  

5. int[]  arr = new int []{1,4,5,8};//1,4,5,8

6.  
7.  
8.  

9. int[] arr;

10.  

11. arr = {1,4,5,8};//编译错误，此方式只能声明同时初始化

12.  

13. arr = new []{1,4,5,8};//正确

4.访问

----访问数组中的数据

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

1. int [] arr = new int [5];

2.  

3. Systrem.out.println("arr.length");

（2）通过下标/索引来访问数组中的元素

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

1. int[]  arr = new int [3];

2.  

3. arr[0] = 100;//给arr第1个元素赋值为100；

4.  

5. arr[1] = 100;//给arr第1个元素赋值为200；

6.  

7. arr[2] = 100;//给arr第3个元素赋值为300；

8.  

9. arr[3] = 400;//运行时，会发生数组下标超出界限（越界）的异常

10.  
11.  
12.  

13. System.out.println (arr.length);//输出数组长度

14.  

15. System.out.println (arr[arr.length-1]);//输出arr中最后一个数组

5. 遍历

----从头到尾看

1. int[] arr = new int [10];

2.  

3. for (int i = 0;i <arr.length;i++){//遍历数组

4.  

5. arr[i] = 100;//给每个元素都赋值为100

6.  

7. arr[i] = (int)(Math.Random.()*100)//赋值100内的随机数

8.  

9. System,out.println(arr[i]);//输出每个元素

10.  

11. }

 

//将arr数组转换为字符串并输出

System.out println(Arrays.toString(arr));//简便输出基本数组

6.复制

方式1:（灵活性更好）

1. int[] a ={10,20,30,40,50};

2.  

3. int[] b =new int[6];

4.  
5.  
6.  

7. System.arraycopy(a, 1, b, 0, 4);

8.  

9. //System.arraycopy(src, srcPos, dest, destPos, length);

10.  

11. //a:源数组(src)

12.  

13. //1：源数组的起始下标(srcPos)

14.  

15. //b:目标数组(dest)

16.  

17. //0:目标数组的起始下标(destPos)

18.  

19. //4:要复制的元素个数(length)

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

方式2：（灵活性差）

1. int[] a = {2,5,3,8,6,7};

2.  

3. int[] b = Arrays.copyOf(a, 6);

4.  

5. //int[] b = Arrays.copyOf(original, newLength)；

6.  

7. //a:源数组(original)

8.  

9. //b:目标数组

10.  

11. //6:目标数组的长度（元素个数）(newLength)

12.  

13. //--若目标数组长度大于源数组长度，则末尾补默认值0

14.  

15. //--若目标数组长度小于源数组长度，则从末尾截掉

16.  
17.  
18.  

19. a = Arrays.copyOf(a,a.length+1);//数组扩容

7.排序

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

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

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

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

（2）升序排列：

1. for (int i = 0; i < arr.length; i++) {

2.  

3. Arrays.sort(arr);

4.  

5. System.out.print(arr[i]+"\t");

6.  

7. }

 

 降序排列：

1. for(int i=arr.length-1;i>=0;i--) {

2.  

3. Arrays.sort(arr);

4.  

5. System.out.print(arr[i]+"\t");

6.  

7. }

十三、方法

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位