java语言基础知识笔记

目录

1.Java开发环境:

  1)java编译运行过程:----------常见面试题

*  2)名词解释:------------------常见面试题

  3)配置环境变量:--------------了解(用到的时候再带着大家装)

2.eclipse:IDE集成开发环境(带图形界面的功能强大的开发工具)

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

  2)开发步骤:

*   3)注释:解释性文本

1.变量:存数的

  1)声明:----相当于在银行开了个帐户

  2)初始化:----相当于给帐户存钱

  3)使用:----使用的是帐户里面的钱

*  4)命名:

* 2.八种基本数据类型:byte,short,int,long,float,double,boolean,char

  1)int:整型，4个字节，-21个多亿到21个多亿（-2147483648 ~ 2147483647）

  2)long:长整型，8个字节，很大很大很大

  3)double:浮点型，8个字节，很大很大很大

  4)boolean:布尔型，1个字节

  5)char:字符型，2个字节

 

 

3.类型间的转换:

1.运算符:

  1)算术运算符

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

  2)关系运算符:

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

  3)逻辑运算符:

    &&,||,! boolean

  4)赋值运算符:

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

  5)字符串连接运算符:

      +

  6)条件/三目运算符:

    boolean?语句1:语句2

    boolean值为true执行语句1；boolean值为false执行语句2

2.分支结构:

  1)if结构: 1条路

  2)if...else结构: 2条路

1,Scanner接受用户输入的数据

1）在package下:

2）在main中：

3）在第二步之后：

1)if结构：1条

2）if...else结构  ：2条

3）if...else if结构：多条

4）switch...case结构：多条路

3，循环结构：

while 结构：

  1）语句：

  2）执行过程：

3）for语句

* 2.三种循环结构的最佳适用情况：

* 3.break与continue

4.嵌套结构：

5.数组：

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

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

3）定义：

4）数组的初始化：---初始化数组中的数据

5）数组的访问：

6）数组的遍历：从头到尾看

7）数组的复制：

8）数组的排序

2.方法（函数、过程）：

 3.方法的定义：

 5.return：

1）return值：

2）return； ：

---

1.Java开发环境:

  1)java编译运行过程:----------常见面试题

    1.1)编译期:.java源文件，经过编译，生成.class字节码文件

    1.2)运行期:JVM加载.class并运行.class(0和1)

    特点:跨平台、一次编程到处使用

*  2)名词解释:------------------常见面试题

    2.1)JVM:java虚拟机

            加载.class并运行.class

    2.2)JRE:java运行环境

            除了包含JVM以外还包含了运行java程序所必须的环境

    JRE=JVM+java系统类库(小零件)

    2.3)JDK:java开发工具包

            除了包含JRE以外还包含了开发java程序所必须的命令工具

    JDK=JRE+编译、运行等命令工具

    说明:

      1)运行java程序的最小环境为JRE

      2)开发java程序的最小环境为JDK

  3)配置环境变量:--------------了解(用到的时候再带着大家装)

    3.1)JAVA_HOME:指向jdk的安装目录

    3.2)CLASSPATH:表示类的搜索路径，一般简写为.

    3.3)PATH:指向jdk下的bin目录

2.eclipse:IDE集成开发环境(带图形界面的功能强大的开发工具)

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

  2)开发步骤:

    2.1)新建Java项目/工程-------------小区

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

    2.3)新建Java类--------------------房子

          main中: System.out.println("hello");

*   3)注释:解释性文本

    3.1)单行注释://

    3.2)多行注释:/*  */

    3.3)文档注释:/**  */

 

 

 

1.变量:存数的

  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)使用:----使用的是帐户里面的钱

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

          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

    3.2)变量在用之前必须声明并初始化

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

  int m;

  //System.out.println(m); //编译错误，变量m未初始化

*  4)命名:

    4.1)只能包含字母、数字、_和$符，并且不能以数字开头

    4.2)严格区分大小写

    4.3)不能使用关键字

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

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

* 2.八种基本数据类型:byte,short,int,long,float,double,boolean,char

  1)int:整型，4个字节，-21个多亿到21个多亿（-2147483648 ~ 2147483647）

    1.1)整数直接量默认为int类型，但不能超范围，若超范围则编译错误

    1.2)两个整数相除，结果还是整数，小数位无条件舍弃(不会四舍五入)

    1.3)运算时若超出范围，会发生溢出(溢出不是错误，但需要避免)

  2)long:长整型，8个字节，很大很大很大

    2.1)长整型直接量需要数字后加L或l(建议用L)

    2.2)float型在后面加F或f

  3)double:浮点型，8个字节，很大很大很大

  4)boolean:布尔型，1个字节

  5)char:字符型，2个字节

 

 

 

3.类型间的转换:

 

byte short char 通常转换为int计算

 

Day03

1.运算符:

  1)算术运算符

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

  2)关系运算符:

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

  3)逻辑运算符:

    &&,||,! boolean

  4)赋值运算符:

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

  5)字符串连接运算符:

      +

  6)条件/三目运算符:

    boolean?语句1:语句2

    boolean值为true执行语句1；boolean值为false执行语句2

2.分支结构:

基于条件执行的语句

  1)if结构: 1条路

  2)if...else结构: 2条路
 

if(boolean){

  语句块

}



boolean flag = true;

if(flag){

}


int a = 5;

if(a>2){

}


int a = 5;

if(a>2 && a<10){

}

 

任何复杂的程序逻辑都可以通过三种结构来实现:

1)顺序结构:从上往下逐行执行，每句必走

2)分支结构:有条件的执行某语句，并非每句必走

3)循环结构:

 

Day04

1,Scanner接受用户输入的数据

1）在package下:

import java.util.Scanner;

2）在main中：

Scanner com = new Scanner(System.in);

3）在第二步之后：

int command = com.nextInt();

2，分支结构

1)if结构：1条

2）if...else结构  ：2条

3）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

4）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);

}

 

 

 

 

3，循环结构：

1)  

while（boolean）{//执行多次

    执行体           //执行多次

    }

 

while 结构：

  1）语句：

  

while（boolean){

   语句块

   }

  2）执行过程：

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

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

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

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

do{

         执行体

     }while(boolean)

 

1）语句：

do{

语句块

}while（boolean）

2）执行过程：

执行语句块，

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

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

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

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

 

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

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

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

if（boolean）{//执行一次

执行体       //执行一次    }

 

3）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（;;){//没有条件的循环是死循环

执行体

}

 

 

* 2.三种循环结构的最佳适用情况：

1）先看循环是否与次数相关

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

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

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

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

 

* 3.break与continue

 break：循环中看到break就跳出循环（在某种特殊条件下提前结束循环）

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

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

 

4.嵌套结构：

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

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

3）建议：嵌套层数越少越好，能有一层就不用两层，能用两层就不用三层

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

4）break只能跳出当前层循环

 

\t：水平制表位（占8位）

 

5.数组：

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

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

3）定义：

int[] arr = new int [10];

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

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

4）数组的初始化：---初始化数组中的数据

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};//正确

 

5）数组的访问：

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

（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中最后一个数组

6）数组的遍历：从头到尾看

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]);//输出每个元素

}

7）数组的复制：

方式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：（灵活性差）i

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);//数组扩容

 

8）数组的排序

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

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

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

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--) {

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

}

2.方法（函数、过程）：

1）封装一段特定的业务逻辑功能

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

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

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

 3.方法的定义：

五要素：

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

方法体

}

 

1）修饰词：public  

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

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

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

     返回值有误判断：

方法执行完后

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

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

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

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

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

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

有参数：方法更加灵活

无参数：

5）方法体：

 4.方法的调用：

1）无返回值：方法名（有参传参）

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

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

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

 5.return：

1）return值：

（1）结束方法的执行

（2）返回结果给调用方

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

2）return； ：

（1）结束方法的执行

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