Java基础知识复习01：从基础知识---面向对象（后续会更新）（1）

在我的资源里有：pdf对应的完整内容需要的可以自行下载，无偿分享给大家

一、快捷键

Alt + / :

1）在java类中，要输出main方法，只要输入main然后用此快捷键按回车即可；

2）要输出System.out.println()，你只需输入syso然后用此快捷键按回车即可；

3）再比如你要覆盖父类的toString()方法，你只需输入to然后用此快捷键按回车；

4）再比如你要用一个没有import的类（比如Calendar），你只需输入Ca然后用此快捷键即可用上下键选择；再比如你要生成某个field的get，set方法，你只需输入get然后用此快捷键生成（默认为public）；

（２）在jsp页面中可用此提示输入标签（标签内提示标签属性）

（３）在xml中也可用此快捷键。

alt+shift+j给函数添加doc注释

Ctrl + Shift + T : 打开Open Type 查找类文件

Ctrl + Shift + F4 : 关闭所在打开的窗口

Ctrl + O : Open declarations

Ctrl + E : 打开编辑器（切换窗口）

Ctrl + / : 注释本行

Alt + Shift + R : 重命名

Alt + Shift + L : 抽取本地变量

Alt + Shift + M : 抽取方法

F3 : Open Declaration

Ctrl + D : 删除本行

Ctrl + SHIFT + F : 整形

Ctrl + Alt + ↓(↑) : 向下(上)复制本行

Alt + ↓(↑) : 向下(上)移动本行

文档注释以 /** 开始，以*/ 结束

二、开发环境搭建

JDK简单理解就是Java开发工具包，JVM也就是常常听到Java虚拟机。JDK是面向开发者的，JRE是面向使用JAVA程序的用户。

bin:最主要的是编译器(javac.exe)

include:java和JVM交互用的头文件

lib：类库

jre:java运行环境

2.1java虚拟机--JVM

JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。

引入Java语言虚拟机后，Java语言在不同平台上运行时不需要重新编译。Java语言使用Java虚拟机屏蔽了与具体平台相关的信息，使得Java语言编译程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。

三、基础概念

位(bit):一个数字0或者一个数字1，代表一位

字节（Byte）：每逢8位是一个字节，这是数据额存储的最小单位。

1Byte=8bit;1KB=1024Byte;1MB=1024K

3.1 关键字特性

1.完全小写的字母。

2.在增强版的记事本当中有特殊颜色。

3.2 标识符

所有标识符必须以字母（a-z，A-Z）美元符（$）下划线（_）开始

首字符后可以用字母（a-z，A-Z）美元符（$）下划线（_）或者数字

注意：1）不能使用变量名

2）不能使用关键字

3）大小写敏感的不能写错

命名规则：

类名规范：首字母大写，后面每个单词首字母大写。

变量名规范：首字母小写，后面每个单词首字母大写。

方法名规范：同变量名。

Java中标识符的命名约定：

小驼峰式命名：变量名、方法名

首字母小写，从第二个单词开始每个单词的首字母大写。

大驼峰式命名：类名

每个单词的首字母都大写。

另外，标识符的命名最好可以做到见名知意

3.3 常量

字符串型：用双引号 " " 引起来的部分。    

整型：无小数点。

浮点型：有小数点

字符：用单引号 ' '        

布尔类型:只有量中取值。true或false

空常量：NULL，无任何数据。

强制转换：

数据类型A 变量a=（数据类型A）变量b

常量：指的是取值不可变的变量

使用final修饰：final 数据类型 变量名=值；

static作用于成员变量用来表示只保存一份副本，而final的作用是用来保证变量不可变。

变量的使用；

1.作为主方法内的一个普通数据

2.定义一个类的属性

类是一种事物的描述

如何描述：特征（属性）与功能（方法）

public class demo01 {
  //定义demo01类的属性，属性名：age
  static int age=13;
  public static void main (String[] args) {
    System.out.println("helloword");
  }
}

在写类中：如何访问属性值？

类名.属性(Byte.MAX_VALUE)来访问

注意事项：

1. 在同一对花括号中，变量名不能重复。

2. 变量在使用之前，必须初始化（赋值）。

3. 定义long类型的变量时，需要在整数的后面加L（大小写均可，建议大写）。因为整数默认是int类型，整数太

大可能超出int范围。

4. 定义flfloat类型的变量时，需要在小数的后面加F（大小写均可，建议大写）。因为浮点数的默认类型是

double， double的取值范围是大于flfloat的，类型不兼容。

3.4数据类型

1、基本数据类型：

1字节=8位

8位：Byte（字节型）  16位：short（短整型）、char（字符型）        

32位：int（整型）、float（单精度型/浮点型）    

64位：long（长整型）、double（双精度型）  最后一个：boolean(布尔类型）

整数型：Byte、short、int、long

浮点型：float、double

字符型：char

布尔型：boolean

类型转换：char-int-long-float-double

2、引用数据类型

字符串、数组、类、接口、Lambda

3、注意事项

1）字符串不是基本类型，二是引用型。

2）浮点型可能只是一个近似值，并非精确的值。

3）数据范围与字节数不一定相关。

4）浮点数当中默认类型是double，如果一定要使用float类型，需加上一个后缀F。

如果是整数，默认为int类型，如果一定要使用long类型，需要加上一个后缀L。

3.5 变量和数据类型

数据类型 变量名称=数据值； int a=2;

自动类型转换（隐式）

1.特点：代码不需要进行特殊处理，自动完成。

2.规则：数据范围从小到大。int --->long

double num = 10; // 将int类型的10直接赋值给double类型 System.out.println(num); // 输出10.0

强制类型转换（显式）:不推荐使用，可能导致精度损失、数据溢出；byte/short/char在运算时都会首先升级为int类型在计算；boolean类型不能发生数据类型转换

1.特点：代码需要进行特殊的格式处理，自动完成。

2.规则：范围小的类型 范围小的变量名 =（范围小的类型）原本范围大的数据。

double num1 = 5.5; int num2 = (int) num1; // 将double类型的num1强制转换为int类型 System.out.println(num2); // 输出5（小数位直接舍弃）

3.6运算符

1、算术运算符

/： 取整除 | 返回除法的整数部分（商） 9 // 2 输出结果 4。

%：取余数 | 返回除法的余数 9 % 2 = 1。

**：幂，又称次方、乘方，2 ** 3 = 8 。

++在非单独使用：

++在后: 会现将变量原本所记录的值取出来进行操作, 然后再完成自身+1的运算。

++在前: 先完成自身+1的运算, 然后再进行赋值。

++/--在单独使用时无区别。

int x = 4;
//括号1 : 现将x原本记录的4取出来  --> 4
//括号2 : 将上一次变化后的5, 再进行++在前的运算 --> 6
//括号3 : 60
int y = (x++)+(++x)+(x*10);  // 70

2、赋值运算符

基本赋值运算符：就一个=

符合运算符：+= -= *= /= %=

eg: a+=1 -->a=a+1

只有变量才能使用赋值运算符，常量不能进行复制。

复合赋值运算符其中隐含了一个强制类型转换

3、比较运算符

== < > <= >= !=

结果一定是boolean值，成立就是true，不成立就是false

如果进行多次判断，不能连者写

4、逻辑运算符：

&逻辑与：a&b，a和b都是true，结果为true，否则为false

|逻辑或：a|b，a和b都是false，结果为false，否则为true

^逻辑异或：a^b，a和b结果不同为true，相同为false

!逻辑非：!a，结果和a的结果正好相反

&&短路与：作用和&相同，但是有短路效果

||短路或：作用和|相同，但是有短路效果

& 与: 与--> 并且--> 结论: 左边两边, 必须同时为true, 结果才为true换句话说, 遇false, 则false.

int i = 10;

System.out.println(i > 5 & i < 20);

| : 或--> 或者--> 结论: 左右两边, 只要有一个为true, 结果就为true换句话说, 遇true, 则true。

&&双与: 短路与 左边返回false的时候, 右边就不再执行了。

左边返回为true, 右边依旧执行。

|| : 至少一个是true就是true；全为false时才为false。

!  : 非--> 取反 --> 特点: 非两次, 结果不变。

^  异或 : 相同为false, 不同为true。

特点 :

一个数, 被另外一个数, 异或两次, 该数本身不变10 ^ 6 ^ 6

&&和& 有什么区别?

& : 无论左边返回的结果是true还是false, 右边都必须执行。

&& : 全为true，才为true；否者为false。

int a=3;

2

||和| 有什么区别?

|| ：一旦判断左边是true之后, 右边就不参与运算了 | ：不管左边是true还是false, 右边都参与运算

5、三元(三目)运算符：

数据类型 变量名称=条件判断(比较表达式) ? 值1 : 值2;

   看比较表达式返回的结果是true还是false

       true : 值1;

       false : 值2;

int i = 10; int i2 = 20; boolean flag = (i == i2) ? true : false;

6、扫描器：

1、导包。Scanner 类在java.util包下，所以需要将该类导入。导包的语句需要定义在类的上面。

import java.util.Scanner;

2、创建Scanner对象。

Scanner sc = new Scanner(System.in); // 创建Scanner对象，sc表示变量名，其他均不可变

3、接收数据

int i = sc.nextInt(); // 表示将键盘录入的值作为int数返回。

扫描器是一种输入

1）引入扫描器类

import java.util.Scanner;

2）新建扫描器对象

Scanner 对象名=new Scanner(System.in)

3）扫描数据"理解为输入一个数据"

扫描整数

扫描器对象.nextInt();

扫描小数

扫描器对象.nextDouble();

扫描字符串

扫描器对象.next();

package day01;
import java.util.Scanner;
public class t2 {
  public static void main(String[] args) {
    Scanner t2=new Scanner(System.in);
    System.out.println("请输入一个整数");
    int x=t2.nextInt();//输入一个整数
    System.out.println("扫描的整数为"+x);//输出整数x
}
}

import java.util.Scanner;
public class t8 {
  public static void main(String[] args) {
    System.out.println("请输入你要判断的车速");
    int speed = new Scanner(System.in).nextInt();
    //在句尾用alt+shift+l  快速接受变量返回值
    if(speed>100&&speed<120) {
      System.out.println("超速");
    }else if(speed>120) {
      System.out.println("警告");
    }}}

练习1：

要求：扫描一个字符串，表示商品名称；扫描一个小数，表示商品单价；扫描一个整数，表示商品数量；输出商品总价；再次扫描所付金额，输出找零数目。

import java.util.Scanner;
public class t3 {
public static void main(String[] args) {
    Scanner t3=new Scanner(System.in);
    String z=t3.next();
    System.out.println("商品名称"+z);
    double y=t3.nextDouble();
    System.out.println("商品单价"+y);
    int x=t3.nextInt();
    System.out.println("商品数量"+x);
    System.out.println("商品总价"+x*y);
    double zhichu=t3.nextDouble();
    System.out.println("付款总额"+zhichu);
    double s=zhichu-x*y;
    System.out.println("找零"+s);}}

首先Random是随机生成数用法，介绍一下：

概述：

Random类似Scanner，也是Java提供好的API，内部提供了产生随机数的功能

API后续课程详细讲解，现在可以简单理解为Java已经写好的代码

使用步骤：

1. 导入包 import java.util.Random;

2. 创建对象 Random r = new Random();

3. 产生随机数 int num = r.nextInt(10);

解释： 10代表的是一个范围，如果括号写10，产生的随机数就是0-9，括号写20，参数的随机数则是0- 19

四、方法和结构

4.1 方法method

定义一个方法的格式：

public static void 方法名称() { 方法体 } 如何调用方法，格式： 方法名称（）；

注意事项：

1.方法定义的先后顺序无所谓

2.方法的定义不能产生嵌套包含关系

3.方法定义好了之后，不会执行的。如果要想执行，一定要进行方法的调用。

public static void main(String[] args) {
              cook();
  }
public static void cook() {
       System.out.println("洗菜")；
       System.out.println("切菜")
       System.out.println("煮菜")
  }

4.2 判断语句

1) if(){

}

else

2) switch

switch (表达式) { case 1: 语句体1; break; case 2: 语句体2; break; ... default: 语句体n+1; break; }

执行流程：

首先计算出表达式的值

其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。

最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

3)for循环

for (初始化语句;条件判断语句;条件控制语句) { 循环体语句; }

格式解释：

初始化语句： 用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样

条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去

循环体语句： 用于表示循环反复执行的内容，简单说就是循环反复执行的事情

条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去

执行流程：

①执行初始化语句

②执行条件判断语句，看其结果是true还是false

如果是false，循环结束

如果是true，继续执行

③执行循环体语句

④执行条件控制语句

⑤回到②继续

4）while循环

初始化语句; while (条件判断语句) { 循环体语句; 条件控制语句; }

while循环执行流程：

①执行初始化语句

②执行条件判断语句，看其结果是true还是false

如果是false，循环结束

如果是true，继续执行

③执行循环体语句

④执行条件控制语句

⑤回到②继续

初始化语句; do { 循环体语句; 条件控制语句; }while(条件判断语句);

执行流程：

① 执行初始化语句

② 执行循环体语句

③ 执行条件控制语句

④ 执行条件判断语句，看其结果是true还是false

如果是false，循环结束

如果是true，继续执行

⑤ 回到②继续

三种循环的区别

for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）

do...while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断） for循环和while的区别

条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了

条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用

死循环（无限循环）的三种格式

1. for(;;){}

2. while(true){}

3. do {} while(true);

跳转控制语句（break）

跳出循环，结束循环

跳转控制语句（continue）

跳过本次循环，继续下次循环

注意： continue只能在循环中进行使用！

break两种用法：

1.可以用在switch语句当中，一旦执行，整个switch语句立即结束。

2.还可以用在循环语句当中，一旦执行，整个循环语句立即结束，打断循环。

continue控制语句：一旦执行，立刻跳过当前次循环剩余内容，马上开始下一次循环。

循环的选择：

凡是次数确定的场景多用for循环；否则多用while循环。

注意事项：

1.多个case后面的数值不可以重复。

2.switch后面的小括号当中只能是下列数据类型：

基本数据类型：byte/short/char/int

引用数据类型：String字符串/enum枚举

3.switch语句格式可以很灵活：前后顺序可以颠倒，而且break语句还可以省略

5）死循环：永远停不下。强制停止ctrl+c

死循环标准格式：

while（true）{

循环体；

}

注意事项：

总结：

1. print为一般输出，同样不能保留精度格式转化，也不能换行输出

2.printf常用于格式转换，但需要注意不是换行输出，只用于精度转换

3.println为换行输出，不能用于格式转换

/*随机数游戏*/
import java.util.Random;
import java.util.Scanner;
public class Suijishu {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Random random = new Random();
        int relNumber = random.nextInt(100) + 1;
        System.out.println("系统会随机产生一个1至100的整数，请猜出这个数！");
        System.out.println("请输入您猜的数字：");
        Scanner reader = new Scanner(System.in);
        int x = reader.nextInt();
        while (x != relNumber) {
            if (x > relNumber) {
                System.out.println("猜大了，请重新尝试");
                x = reader.nextInt();
            } else {
                System.out.println("猜小了，请重新尝试");
                x = reader.nextInt();
            }
        }
        System.out.println("恭喜您，猜对了！");
    }
}

五、方法提升

5.1、定义方法完整格式：

修饰符 返回值类型 方法名称（参数类型 参数名称，......）{

方法体

return返回值；

}

public static int sum(int a , int b) {
        System.out.println("方法执行");
        int result=a+b;
        return result;
    }

修饰符：现阶段固定写法，public static

返回值类型：也就是方法最终产生的数据结果是什么类型

方法名称：方法的名字，规则和变量一样，小驼峰

小驼峰命名规则：第一个单词小写，其他单词首字母大写 写法如：myFirstName 大驼峰命名规则：第一个单词首字母大写，其他单词首字母也大写 写法如：MyFirstName

参数类型：进入方法的数据是什么类型

参数名称：进入方法的数据对应的变量名称

PS：参数如果有多个，是用逗号进行分割

方法体：方法需要做的事情。若干行代码

return：两个作用，第一个是停止当前方法；第二个是将后面的返回值还给调用出

返回值：也就是方法执行后最终产生的数据结果

public class define {
    public static void main(String[] args) {
        sum(2,3);
        System.out.println();
        System.out.println(sum(1,3));
    }
    public static int sum(int a , int b) {
        System.out.println("方法执行");
        int result=a+b;
        return result;
    }}

注意：return后面的“返回值”，必须和方法名称前面的“返回值类型”，保持对应

定义一个两个int数字相加的方法。

三要素

{返回值类型：int 方法名称：sum 参数列表：int 啊，int b}

方法的三种调用格式：

1.单独调用：方法名称（参数）；

sum(2,3); System.out.println();

2.打印调用：System.out.println(方法名称（参数）);

System.out.println(sum(1,3));

3.赋值调用：数据类型 变量名称=方法名称（参数）；

int number=sum(1,2);

import java.util.Scanner;
public class t3 {
    public static void main(String[] args) {
        System.out.println("请输入第一个数字");
        int x=new Scanner(System.in).nextInt();
        System.out.println("请输入第二个数字");
        int y=new Scanner(System.in).nextInt();
        System.out.println("请输入运算符");
        int q=new Scanner(System.in).nextInt();
        if(q==1){
            System.out.println(add(x,y));
        }else if(q==2){
            System.out.println(chengfa(x,y));
        }else if(q==3){
            System.out.println(jianfa(x,y));
        }
    }
    public static int  add(int a,int b) {
        int sum=a+b;
        return sum;
    }
    public static int  chengfa(int a,int b) {
        int cf=a*b;
        return cf;
    }
    public static int  jianfa(int a,int b) {
        int jf=a-b;
        return jf;
    }
}