Java基础学习笔记(基本规范、变量定义、运算符、分支/循环结构、函数)

文章目录

• ​​Java概述与环境搭建​​

• ​​Java历史​​
• ​​Java语言特点​​
• ​​Java执行机制​​
• ​​安装jdk​​
• ​​环境变量配置​​
• ​​乱码问题解决​​

• ​​基本规范​​

• ​​简单Java代码​​
• ​​编译运行​​
• ​​注释​​
• ​​语法规则​​

• ​​变量类型​​

• ​​声明方式​​
• ​​基本数据类型​​

• ​​问题：数据类型不兼容​​

• ​​赋值案例​​
• ​​字符型常量​​
• ​​转义字符​​
• ​​字符串​​
• ​​类型转换​​

• ​​运算符​​

• ​​算数运算符​​
• ​​关系运算符​​
• ​​逻辑运算符​​
• ​​自增自减运算符​​
• ​​短路(断路)原则​​

• ​​输入​​

• ​​控制台获取输入​​

• ​​选择结构和分支结构​​

• ​​if分支​​
• ​​switch​​
• ​​条件运算符/三目运算符​​

• ​​局部变量​​
• ​​循环结构​​

• ​​break/continue​​

• ​​函数/方法​​

• ​​无参数无返回值方法​​
• ​​有参数无返回值方法​​
• ​​无参数有返回值方法​​
• ​​有参数有返回值方法​​
• ​​总结​​
• ​​编程题​​
• ​​方法封装​​
• ​​方法文档注释规范​​
• ​​方法封装​​
• ​​方法文档注释规范​​

Java概述与环境搭建

Java历史

sun（Stanford University Network）,1995年推出Java面向对象的程序设计语言

2014年由Oracle发布Java8.0（较为主流）

Java之父：詹姆斯·高斯林

oracle甲骨文公司，oracle数据库、MySQL数据库都是旗下产品

Java语言特点

• 面向对象（贴近人类思维模式）
• 简单（相对于c、c++、c#，不易造成内存溢出，减少代码量，代码可读性强）
• 跨平台（windows、linux（读：里讷克斯/'linэks/）、macos、unix）

Java的jvm，能够帮助Java程序可以支持不同的平台

Java执行机制

Java程序编译后生成.class字节码文件，通过jvm在不同平台上给予不同的解释，可以满足很多地方同时运行

• 编译执行：c、c++
  编译的结果直接交给cpu运行，效率极高，不能跨平台
• 解释执行：Java、c#、PHP、python
  编译结果需要通过解释器解释之后再交给cpu执行，效率较低
  Java通过JIT技术达到类和c++相近的效率

JVM

Java Virtual Machine

使用软件在不同的操作系统中，模拟相同的环境

JRE

Java Runtime Environment

包含jvm和解释器，完整的Java运行环境

JDK

Java Development Kit

包含jre，类库，开发工具包（编译器+调试工具）

安装jdk

下载jdk8

安装路径尽量不要选择c盘，安装路径一定不要有中文

jdk文件

• bin目录
  binary二进制目录
  都是二进制可以执行文件，包含.exe文件
  java.exe,javac.exe,javap.exe,javadoc.exe
• db
  jdk自带小型数据库（用处不大）
• include
  系统接口目录
• jre
  java运行环境，java runtime environment
• lib
  资源库目录，存在一些.jar文件，jar包
• src.zip
  java的完整源代码

环境变量配置

1. win+e打开资源管理器
   我的电脑-属性-高级系统设置-高级-环境变量
   

用户变量只针对当前用户，系统变量是全部

1. 设置变量
   系统变量修改:
   新建：
   变量名:JAVA_HOME
   变量值:D:\Program Files\Java\jdk1.8.0_211
   新建:
   变量名:CLASS_PATH
   变量值:.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar
   修改:
   变量名:path
   添加内容:
   ;%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;
   注意：标点符号为英文半角
2. 切换jdk版本
   Java无法做到python，同时拥有两个版本，环境只能有一套
   切换时直接更改环境变量设置，也就是JAVA_HOME
   设置环境变量时这么做也是方便修改
   本机java位置：
   8：E:\Program\Java
   14：C:\Program Files\Java\jdk-14.0.2
3. 安装完毕后，测试
   java --version

即为设置成功

乱码问题解决

安装完毕后，发现输入命令会有乱码，可能有电脑编码问题有关，之前flask运行不起来，更改了电脑的编码

解决方法：

设置一个系统环境变量

JAVA_TOOL_OPTIONS
-Dfile.encoding=UTF-8

退出cmd，重新进入

问题解决

dos命令

• rd删除目录
• del直接删除文件
• echo输出
• cls清理屏幕
• exit退出

基本规范

Java一切皆是对象

简单Java代码

FirstJava.java

class FirstJava {
    public static void main(String[] args) {
        System.out.println("welcome to java world!!!");
    }
}

保存文件名与类名相同

注意大小写及拼写问题

编译运行

javac 源文件名.java

编译之后会生成一个FirstJava.class文件

.class字节码文件，二进制文件，需要借助jvm执行解释

默认编译成功不会有输出，和linux一样没有错误就是正确，因为更改了字符所以有一行字符的提示

执行

注释

单行注释

// 单行注释

多行注释

/* 多行注释 */

文档注释

/** 文档注释 */

语法规则

• 可以有字母，数字，_，$组成，不能以数字开头
• 不能与关键字，保留字重名

参考AJCG阿里巴巴Java开发规约

标识符

类名，方法名，变量名

AJCG规范

• 标识符可以使用的字符范围，英文字母（A-Z，a-Z）数字（0-9）唯一可以使用的标点符号_
• 标识符要求必须英文字母开头
• 标识符严格区分大小写
• 标识符没有严格的长度限制，但是会根据实际需求来限制标识符的长度
• 标识符需要做到见名知意，动宾结构，如getStudentAge
• 使用驼峰命名法和下划线命名法
  小驼峰【适用于变量名、方法名】：多个单词构成标识符时，第一个单词首字母小写，之后的单词首字母大写
  大驼峰【适用于类名、接口名】：标识符所有的单词首字母大写
  下划线：所有字母都是大写的情况下，为了区分单词的间隔，使用下划线命名法，如JAVA_HOME
• 已经被Java使用的关键字和保留字不得用于自定义标识符使用（也就是在编译器中变色的的不能用）

变量类型

Java是强类型语言，变量的类型必须与数据的类型一致

注意:变量未定义不能使用,未赋值不能使用(只能先赋值)

声明方式

三种声明方式

1. 先声明，在赋值
   数据结构 变量名;
   变量名 = 值;
2. 声明并赋值(推荐)
   数据结构 变量名 = 值;
3. 多个同类型变量的声明与赋值（不推荐）
   数据类型 变量1,变量2 = 值1,变量3,变量4 = 值2;

基本数据类型

Java有2种类型，8种基本数据类型

整型

小数、浮点数

布尔类型

字符类型

问题：数据类型不兼容

• float

/*浮点型变量*/
        /*float floatNumber = 3.14; 会报错*/
        double doubleNumber = 0.618;

        /*浮点型数据展示*/
        System.out.println(floatNumber);
        System.out.println(doubleNumber);

计算机为了保证数据的精度，同时为了数据后期的延展性，默认为double类型，double占用的内存空间是8字节，而float是4个字节

解决方法：在float小数后面加上大写F

float floatNumber = 3.14F;

• long

long类型的数据需要在常量后加上一个大写的L，明确告知计算机这里使用的是一个long类型的数据

赋值案例

class VariableTest {
    public static void main(String[] args){
        /*整形数据*/
        byte byteNumber = 10;
        short shortNumber = 20;
        int intNumber = 20;
        long longNumber = 40L;
        
        /*整形数据展示*/
        System.out.println(byteNumber);
        System.out.println(shortNumber);
        System.out.println(intNumber);
        System.out.println(longNumber);

        /*浮点型变量*/
        /*float floatNumber = 3.14; 会报错*/
        float floatNumber = 3.14F; 
        double doubleNumber = 0.618;

        /*浮点型数据展示*/
        System.out.println(floatNumber);
        System.out.println(doubleNumber);

        /*
        字符型变量
        字符常量:单引号包含的单个字符元素'a'
        */
        char ch1 = 'A';
        char ch2 = '中';

        System.out.println(ch1);
        System.out.println(ch2);

        /*布尔类型*/
        boolean ret1 = true;
        boolean ret2 = false;

        System.out.println(ret1);
        System.out.println(ret2);
        
        /*
        int num;
        System.out.println(num);
        会报错,java在没有赋值的情况下,不能使用
        */
    }
}

字符型常量

字符常量:单引号包含的单个字符元素 如：‘a’

使用要求:

有且只允许使用字符本身,如’a’,‘A’,不建议使用’97’,‘65’

优势：

1. 阅读型好
2. 保证数据类型一致化
3. 减少了没有必要的歧义

转义字符

\ 反斜杠

将带有特定含义字符转换为无意义字符，或者将无意义字符，转换成带有一定含义字符

只能转义后边的一个字符

\'
\"
\n  换行
\t  tab
\\  一个反斜杠
\\\\  两个反斜杠

class Demo3 {
    public static void main(String[] args){
        char ch = '\'';
        
        System.out.println(ch);
        System.out.println("test\ttest");
        System.out.println("test\ntest");
        System.out.println("test\ntest");
        System.out.println("test\\test");
    }
}

字符串

羊肉和羊肉串的关系

字符串特定标记

" "英文双引号包含的所有内容都是字符串本身，并且是一个常量，不可以修改

String

类型转换

自动类型转换：

• 小变大
• 两种类型相互兼容
• 目标类型大于源类型

如：

short s = 123;
int i = s;

强制类型转换：

• 大变小
• 两种类型相互兼容
• 目标类型小于源类型

如：

short s = 123;
byte b = (byte) s;

不推荐使用：会导致数据精度的丢失

强制类型转换在面向对象开发中，可以用来操作对象

运算符

算数运算符

+  -  *  /  %  ()
+=  -=  *=  /=  %=

• 从左到右计算
• 先乘除后加减
• 右括号先处理括号里面的内容
• 除数不能为0

关系运算符

>  大于
<  小于
>= 大于等于
<= 小于等于
==  等于
!=  不等于

结果是:true,false

逻辑运算符

&&  与,同真为真,有假即假
||  或,有真即真,同假为假
! 非,取反

自增自减运算符

++  自增
--  自减

class Demo4 {
    public static void main(String[] args) {
        int num = 10;
        System.out.println("num++ : " + num++);
        System.out.println("num : " + num);
        System.out.println("++num : " + ++num);
        System.out.println("num : " + num);
    }
}

++在变量之后(num++),首先执行变量所在行语句,再执行自增加1操作

++在变量之前,首先执行变量自增加1操作,再执行变量所在语句

注意:

1. 自增自减运算符有且只能操作变量
2. 自增自减运算符独立存在,就是对变量操作,减少歧义

短路(断路)原则

class Demo4 {
    public static void main(String[] args) {
        int num = 10;
        boolean ret = 10 > 15 && num++ >= 10;
        System.out.println(ret);
        System.out.println(num);

        int num1 = 10;
        boolean ret1 = 10 > 5 || ++num1 > 5;
        System.out.println(ret1);
        System.out.println(num1);
    }
}

逻辑与断路:当第一个条件为false,整个表达式结果为false,不在判断之后的条件

逻辑或短路:当第一个条件为true时,整个表达式结果为true,不在判断之后的条件

输入

控制台获取输入

1. 导包
   import java.util.Scanner
2. 获取Scanner的变量,扫描器的一个变量
   Scanner sc = new Scanner(System.in)
3. 使用Scanner其中的方法
   获取int类型数据 sc.next.Int()
   获取double类型数据 sc.nextDouble()
   获取String类型字符串数据 sc.next();sc.nextLine()
   获取一个char类型字符数据 sc.next().charAt(0),sc.nextLine().charAt(0)

import java.util.Scanner;
class Demo4 {
    public static void main(String[] args) {
        int num = 0;
        Scanner sc = new Scanner(System.in);
        System.out.println("please input a integer");
        num = sc.nextInt();
        System.out.println("num:" + num);
    }
}

import java.util.Scanner;
class Demo4 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        char ch = '\0';
        System.out.println("please input a char");
        ch = sc.nextLine().charAt(0);
        System.out.print("ch:" + ch);
    }
}

多个字符也只能接受一个字符

选择结构和分支结构

if分支

if ( /*判断条件*/ ) {
    // 执行体
}


if ( /*判断条件*/ ) {
    // 执行体
} else {
    // 执行体
}


if ( /*判断条件*/ ) {
    // 执行体
} else if ( /*判断条件*/ ) {
    // 执行体
} else {
    // 执行体
}

分数范围判断案例

import java.util.Scanner;
class Demo4 {
    public static void main (String[] args) {
        float score = 0.0F;
        System.out.println("请输入分数值：");
        Scanner sc = new Scanner(System.in);
        score = sc.nextFloat();

        if (score < 0 || score > 100) {
            System.out.println("范围不正确");
            System.exit(0);
        } else if (score >= 90) {
            System.out.println("优秀");
        } else if (score >= 80) {
            System.out.println("良好");
        } else if (score >= 70) {
            System.out.println("中等");
        } else if (score >= 60) {
            System.out.println("及格");
        } else {
            System.out.println("不及格");
        }
    }
}

switch

switch (变量|表达式) {
    case 值1:
        逻辑代码1;
        break;
    case 值2:
        逻辑代码2;
        break;
    case 值n:
        逻辑代码n;
        break;
    default:
        为满足时的逻辑代码;
        break;
}

switch语句可判断的变量类型有byte,short,int,char,String(jdk7+)

注意:break必须要加,标签值(case后边的值)不能重复

条件运算符/三目运算符

条件判断?true:false

局部变量

存在与代码块中的变量

class Demo5 {
    public static void main (String[] args) {
        int num = 10;
        if (num > 5) {
            int num2 = 10;
        }
        System.out.println(num);
        System.out.println(num2);
    }
}

编译报错,num2不会存在

num2是一个局部变量,自能在if大括号(作用域)内使用

注意:

1. 局部变量有且只能在当前所处的代码块中使用,超出当前代码块范围无效
2. 在作用域范围以内,任何的地方可以直接使用对应的变量
3. 在一个变量的作用域范围以内,不能重定义同名变量,会报错
4. 局部变量未赋值不能使用

循环结构

while循环

while (/*循环条件*/) {
    // 循环体
}

do-while

do {
    执行循环语句
} while (条件表达式);

for

for (初始条件; 循环检测条件; 循环后更新计数器) {
    // 执行语句
}

如:
for (int i=1; i<=100; i++) {
    sum = sum + i;
}

break/continue

​​break​​会跳出当前循环，也就是整个循环都不会执行了

​​continue​​则是提前结束本次循环，直接继续执行下次循环

函数/方法

public static void main(String[] args) {
    // 方法体
}
// public static后续内容补充
// void表示没有返回值
// main表示方法名
// (String[] args)形参列表

public static ReturnType MethodName (Arguments) {
    Method Body
}

无参数无返回值方法

class Demo5 {
    public static void main (String[] args) {
        bbq();
        bbq();
        bbq();
    }

    public static void bbq () {
        System.out.println("BBQ Method");
    }
}

有参数无返回值方法

单个参数

需求:展示一个int类型数据

class Demo6 {
    public static void main(String[] args) {
        // 带有参数的方法一定要提供对应的数据类型，实际参数
        printIntNum(10);
    }

    /**
     * 文档注释格式
     * 打印一个int类型数据
     * 
     * @param num 要求用户传入一个int类型数据
     */
    public static void printIntNum(int num) {
        System.out.println("num:" + num);
    }
}

调用时注意事项:

1. 带有参数的方法一定要提供对应的数据类型,实际参数
2. 调用带有参数的方法,给与实际参数是,数据类型应该一致

多个参数

形式参数列表:两个int类型数据

class Demo6 {
    public static void main(String[] args) {
        // 带有参数的方法一定要提供对应的数据类型，实际参数
        printIntNum(10);
        printSumOfTwoNum(10, 5);
    }

    /**
     * 文档注释格式
     * 打印一个int类型数据
     * 
     * @param num 要求用户传入一个int类型数据
     */
    public static void printIntNum(int num) {
        System.out.println("num:" + num);
    }

    /**
     * 打印两个参数之和
     * @param num1
     * @param num2
     */
    public static void printSumOfTwoNum(int num1,int num2) {
        System.out.println("sum:" + (num1+num2));
    }
}

• 形参与实参个数与数据类型必须一致

无参数有返回值方法

class Demo6 {
    public static void main(String[] args) {
        int num = 0;
        System.out.println("before :" + num);
        num = giveMeFive();
        System.out.println("after :" + num);
    }

    public static int giveMeFive() {
        return 5;
    }
}

注意:方法中需要返回值,必须有一个明确的return

如:这样会报错

public static int giveMeFive() {
        if(true) {
            return 5;
        }
    }

正确写法:

public static int giveMeFive() {
        if(true) {
            return 5;
        } else {
            return 10;
        }
    }

方法中返回值类型是void,可以使用return作为方法的结束,return之后不能有任何数据

有参数有返回值方法

例:计算两个int类型数据之和,返回结果

class Demo7 {
    public static void main(String[] args) {
        int sum = 0;
        sum = getSumOfTwoNum(10, 8);
        printSumNum(sum);
    }

    /**
     * 计算两个int类型数据之和,返回结果
     * @param num1
     * @param num2
     * @return
     */
    public static int getSumOfTwoNum(int num1,int num2) {
        int sum = 0;
        sum = num1 + num2;
        return sum;
    }
    
    /**
     * 输出打印两数之和sum值
     * @param sum
     */
    public static void printSumNum(int sum) {
        System.out.println("sum:" + sum);
    }
}

总结

方法的三要素

返回值
方法名
参数列表

返回值:

• 选择合适的返回值类型
• 方法中需要返回值,必须有明确的return
• 一个方法有且只能由一个返回值类型

方法名:

• 见名知意,动宾结构,小驼峰命名法
• 英文命名

形式参数列表:

• 调用方法时,形式参数列表和实际参数列表参数个数与类型是一致的,顺序也是一致的
• 考虑好对应的数据类型

编程题

分解质因数

例如：91=7*13

class Demo8 {
    public static void main(String[] args) {
        int num = 91;
        for(int i = 2; i <= num ; i++) {
            System.out.println('*');
            if (num % i == 0) {
                System.out.println("num:" + i);
                num /= i;
                i -= 1;
                // 如果能被整除，i-1判断是否还能被整除一次
            }
        }
    }
}

优化版

class Demo8 {
    public static void main(String[] args) {
        int num = 91;
        for(int i = 2; i <= Math.sqrt(num) ; i++) {
            System.out.println('*');
            if (num % i == 0) {
                System.out.println("num:" + i);
                num /= i;
                i -= 1;
            }
        }
        System.out.println("num:" + num);
    }
}

因为一个数的最大的质数,一定小于这个数的平方根,如,91的最大的质数就是7,另一个质因数就是91/7=13,可以减少循环次数,时间复杂度

方法封装

• 功能单一化
• 考虑后期的复用性,可移植性,模块化
• 减少代码中return的使用,提高代码阅读性
• 找出特定情况优化代码,提高效率

方法文档注释规范

文档注释规范

/**
 * 对于当前的整体解释，可以把方法的分析过程，利害关系全写上
 * 
 * @param argumentName参数名字，对于当前参数的功能解释，提一些要求，有多少个参数就需要完成多少@param
 * 
 * @return 返回值解释，数据类型，返回值的含义，状态，要求
 */

num % i == 0) {
System.out.println(“num:” + i);
num /= i;
i -= 1;
// 如果能被整除，i-1判断是否还能被整除一次
}
}
}
}

[外链图片转存中...(img-93XCDAuB-1620135462494)]

优化版

```java
class Demo8 {
    public static void main(String[] args) {
        int num = 91;
        for(int i = 2; i <= Math.sqrt(num) ; i++) {
            System.out.println('*');
            if (num % i == 0) {
                System.out.println("num:" + i);
                num /= i;
                i -= 1;
            }
        }
        System.out.println("num:" + num);
    }
}

因为一个数的最大的质数,一定小于这个数的平方根,如,91的最大的质数就是7,另一个质因数就是91/7=13,可以减少循环次数,时间复杂度

[外链图片转存中…(img-j8kF88mD-1620135462495)]

方法封装

• 功能单一化
• 考虑后期的复用性,可移植性,模块化
• 减少代码中return的使用,提高代码阅读性
• 找出特定情况优化代码,提高效率

方法文档注释规范

文档注释规范

/**
 * 对于当前的整体解释，可以把方法的分析过程，利害关系全写上
 * 
 * @param argumentName参数名字，对于当前参数的功能解释，提一些要求，有多少个参数就需要完成多少@param
 * 
 * @return 返回值解释，数据类型，返回值的含义，状态，要求
 */