java基础学习笔记上_小言_互联网的博客

java基础学习笔记上

2021-05-06 09:31 376人阅读评论(0)

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的完整源代码

环境变量配置

win+e打开资源管理器

我的电脑-属性-高级系统设置-高级-环境变量

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

系统变量修改:

新建：
变量名: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;

注意：标点符号为英文半角
切换jdk版本

Java无法做到python，同时拥有两个版本，环境只能有一套

切换时直接更改环境变量设置，也就是JAVA_HOME

设置环境变量时这么做也是方便修改

本机java位置：

8：E:\Program\Java

14：C:\Program Files\Java\jdk-14.0.2
安装完毕后，测试

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 = 值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’

优势：

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

转义字符

\ 反斜杠

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

只能转义后边的一个字符

\'
\"
\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操作,再执行变量所在语句

注意:

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

短路(断路)原则

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,不在判断之后的条件

输入

控制台获取输入

导包

import java.util.Scanner
获取Scanner的变量,扫描器的一个变量

Scanner sc = new Scanner(System.in)
使用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大括号(作用域)内使用

注意:

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

循环结构

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);
    }
}

调用时注意事项:

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

多个参数

形式参数列表:两个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 返回值解释，数据类型，返回值的含义，状态，要求
 */

转载：https://blog.csdn.net/q20010619/article/details/116405700

查看评论

小言_互联网的博客

小言_互联网的博客

个人资料

文章分类

文章存档

阅读排行

评论排行

推荐文章