java基础自学

最新推荐文章于 2024-07-09 16:17:35 发布

白给是个技术活！

最新推荐文章于 2024-07-09 16:17:35 发布

阅读量131

点赞数

文章标签： java 开发语言学习

本文链接：https://blog.csdn.net/weixin_45812603/article/details/131785476

版权

JAVA基础day01

1.JAVA介绍（了解）

java历史

SUN公司为了抢占市场先机，在1991年成立了一个由詹姆斯·高斯林（James Gosling）领导，名为

“Green”项目小组，目的是开发一种能够在各种消费性电子产品上运行的程序架构。

1994年，项目小组看到了浏览器在未来的发展前景，于是决定将OaK应用于万维网。1995年，他们用

OaK语言研发了一种能将小程序嵌入到网页中执行的技术——Applet，由于Applet不仅能嵌入网页，还

可随同网页在网络上进行传输，这让无数的程序员看到了OaK这门语言，与此同时，OaK正式更名为

Java。从此，Java在互联网的推动下火了。

JAVA演变

1991年 Green项目，开发语言最初命名为Oak (橡树)

1994年，开发组意识到Oak 非常适合于互联网

1996年，发布JDK 1.0，约8.3万个网页应用Java技术来制作

1997年，发布JDK 1.1，JavaOne会议召开，创当时全球同类会议规模之最

1998年，发布JDK 1.2，同年发布企业平台J2EE

1999年，Java分成J2SE、J2EE和J2ME，JSP/Servlet技术诞生

2004年，发布里程碑式版本：JDK 1.5，为突出此版本的重要性，更名为JDK 5.0

2005年，J2SE -> JavaSE，J2EE -> JavaEE，J2ME -> JavaME

2009年，Oracle公司收购SUN，交易价格74亿美元

2011年，发布JDK 7.0

2014年，发布JDK 8.0，是继JDK 5.0以来变化最大的版本

2017年，发布JDK 9.0，最大限度实现模块化

2018年3月，发布JDK 10.0，版本号也称为18.3

2018年9月，发布JDK 11.0，版本号也称为18.9

java长期支持版本

java8=jdk8

java11=jdk11

java17=jdk17

jdk8：垃圾回收机制Parallel GC

jdk11：ZGC

jdk17：ZGC默认启用

java特性

一种纯面向对象的编程语言。

一种与平台无关（跨平台）的语言。(它提供了在不同平台下运行的解释环境)

一种健壮的语言，吸收了C/C++语言的优点。

有较高的安全性。(自动回收垃圾，强制类型检查，取消指针)

java技术的两种核心机制

1.Java虚拟机(Java Virtual Machine) JVM

2.垃圾回收器(Garbage Collection) GC

java虚拟机（JVM)（重要）

JVM可以理解成一个可运行Java字节码的虚拟计算机系统

它有一个解释器组件，可以实现Java字节码和计算机操作系统之间的通信

对于不同的运行平台，有不同的JVM。

JVM屏蔽了底层运行平台的差别，实现了“一次编译，随处运行”。

垃圾回收器（GC)（重要）

不再使用的内存空间应当进行回收-垃圾回收。

在C/C++等语言中，由程序员负责回收无用内存。

Java语言消除了程序员回收无用内存空间的责任：

JVM提供了一个系统线程，用于跟踪存储空间的分配情况，检查并释放那些可以被释放的存储空间。

垃圾回收器在Java程序运行过程中自动启用，程序员无法精确控制和干预。

JDK、JRE、JVM

JDK:Java开发工具包

JDK是提供给Java开发人员使用的，其中包含了java的开发工具，也包括了JRE。所以安装了JDK，就不用再单独安装JRE了。其中的开发工具包括：编译工具(javac.exe) 打包工具(jar.exe)等。

JRE:Java运行时环境

包括Java虚拟机(JVM Java Virtual Machine)和Java程序所需的核心类库等，如果想要运行一个开发好的Java程序，计算机中只需要安装JRE即可。

JVM：Java虚拟机

jdk、jre、jvm关系图：

2.环境搭建

2.1 Java安装

2.1.1 安装JDK

目前长期支持的jdk版本有JDK8、JDK11、JDK17，这里推荐去官网安装JDK11。如果下载慢可以选择去国内镜像网站下载。

2.2 idea的安装与配置

可以参考别的博主安装教程

2.3 环境配置

JAVA_HOME配置：jdk安装路径

Path配置：命令javac的寻址路径

Java程序开发步骤

1.将java代码写到.java文件当中

2.用Javac将.java文件编译为.class文件

3.通过 java 命令对生成的 class 文件进行运行。

3. 变量与数据类型

3.1 标识符

命名规范参考Java开发手册（嵩山版）
**Java对包、类、方法、参数和变量等要素命名时使用的字符序列称为标识符。**命名规则如下:
由字母、数字、下划线（_）和美元符号（$）组成。不能以数字开头。
区分大小。
长度无限制。
不能是Java中的保留关键字。
命名规范：软性建议
标识符命名习惯：见名知意。

类名规范：首字母大写，后面每个单词首字母大写（大驼峰式）。方法名规范：首字母小写，后面每个单词首字母大写（小驼峰式）。变量名规范：首字母小写，后面每个单词首字母大写。

包名规范：全都小写。

3.2 关键字

Java中有一些赋予特定的含义，有专门用途的字符串称为关键字（keyword）。全部是小写。

保留字：没有定义用途，但保留备用。
例如：goto、const

3.3 进制

3.3.1 二进制

计算机中的数据都以二进制数字保存。
二进制：逢二进一。即只有0、1两个值。

如：十进制的10在计算机内保存为二进制的1010
计算机中信息的存储单位
**位（Bit）：**表示一个二进制数码0或1，是计算机存储处理信息的最基本的单位。
字节（Byte）：一个字节由8个位组成。它表示作为一个完整处理单位的8个二进制数码。

**英文：**一个字符(字母、空格、符号等）占一个字节

**中文：UTF-8中一个汉字大部分占3个字节少量的占更多字节 GBK中汉字一般占两个字节

字：32位计算机：1字=32位=4字节，64位计算机：1字=64位=8字节

3.3.2 十六制

二进制表示法太冗长，所以在程序中一般喜欢用十六进制。
十六进制：基数为十六，逢十六进一。它用abcdef表示从0-9之上的值。
Java中十六进制数据要以0x或0X开头。如：0x23D
十六进制转换成二进制只需将每个十六进制数字替换为相对应的四个二进制位即可。

3.3.3 八进制

八进制：基数为八。
Java中八进制数据要以0开头。如：0123
八进制转换成二进制：只需将每个八进制数字替换为相对应的三个二进制位即可。现在的计算机系统很少用八进制的了。

3.3.4 原码、反码、补码（了解）

1.原码

十进制数据的二进制表现形式就是原码，原码最左边的一个数字就是符号位，0为正，1为负。

例如：56 -> 0 0 1 1 1 0 0 0
左边第一位为符号位，其他位为数据位

一个 byte 有 8bit，最大值是 0 1 1 1 1 1 1 1 (+127)，最小值是 1 1 1 1 1 1 1 1 (-127)

（1）正数计算

使用原码没有问题

（2）负数计算（用反码进行计算）

但是如果是负数的话，那计算的结果就会大相径庭了
我们拿 -56 这个数字来举例，它的原码是 1 0 1 1 1 0 0 0 ，减一之后，就会变成 1 0 1 1 0 1 1 1 ，这个数转成十进制就是 -55。计算前是 -56，减一之后正确的结果应该是 -57（1 0 1 1 1 0 0 1）才对，居然还越减越大了

2.反码（负数计算来用）

正数的反码是其本身（等于原码），负数的反码是符号位保持不变，其余位取反。 反码的存在是为了正确计算负数，因为原码不能用于计算负数。

3.补码(跨0计算来用)

**正数的补码是其本身，负数的补码等于其反码 +1。**因为反码不能解决负数跨零（类似于 -6 + 7）的问题，所以补码出现了。

总结：

原码：最高位符号位，0表示正数，1:表示负数
反码：正数的补码不变，负数反码：符号位不变，其他按位取反，解决负数的计算问题
补码：正数的补码不变，负数补码是反码+1，解决跨零计算问题

3.4 数据类型

3.4.1 基本数据类型（重要）

类型	占用内存	值范围(含边界值)	默认值
整数型(int)	4字节	-2 147 483 648 ~ 2 147 483 647（稍大于20亿）	0
短整数型（short）	2字节	-32 768 ~ 32 767	0
长整数型（long）	8字节	-9 223 372 036 854 775 808L ~ 9 223 372 036 854775 807L	0
浮点型（float）	4字节	-3.40292347E+38-3.40292347E+38	0.0f
双精度型（double）	8字节	-1.79769313486231570E+308-
1.79769313486231570E+308	0.0d
布尔型
（boolean）	1字节	true 或 false	false
字符型（char）	2字节	‘ \u0000 - u\ffff ’	‘\u0000

ASCII码

3.4.2 基本数据类型转换（重要）

**自动类型转换：**容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：

有多种类型的数据混合运算时，**系统首先自动将所有数据转换成容量最大的那种数据类型，**然后再进行计算。
byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。
boolean类型不能与其它数据类型运算。
当把任何基本数据类型的值和字符串(String)进行连接运算时(+)，基本数据类型的值将自动转化为字符串(String)类型。

3.4.3 字符串类型 String

String不是基本数据类型，属于引用数据类型
使用方式与基本数据类型一致。例如：String str = “abcd”;
一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。例如：

str = str + “xyz” ;
int n = 100;
str = str + n;

结果判断

String str1 = 4; //判断对错：no
String str2 = 3.5f + “”; //判断str2对错：yes
System.out.println(str2); //输出：”3.5”
System.out .println(3+4+“Hello!”); //输出：7Hello!
System.out.println(“Hello!”+3+4); //输出：Hello!34
System.out.println(‘a’+1+“Hello!”); //输出：98Hello!
System.out.println(“Hello”+‘a’+1); //输出：Helloa1

3.4.4 强制类型转换（重要）

自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符：()，但可能造成精度降低或溢出,格外要注意。
通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。

String a = “43”; int i = Integer.parseInt(a);

3.5 变量

3.5.1 定义

变量就是系统为程序分配的一块内存单元，用来存储各种类型的数据。简单理解就是内存中一块空间的表示。
由于该存储单元中的数据可以发生改变，因此得名为"变量"。

3.5.2 声明变量

3.5.2.1 方式1：先声明变量后赋值

语法：数据类型变量名称；

int a; 
a = 3；

3.5.2.2 方式2：声明变量的同时赋初值

语法：数据类型变量名称=值;

int a = 3;

3.5.2 变量的使用

      /*
        * 变量的声明与使用
        */
        //变量的声明
        // 1.变量的使用,先赋值再使用
        int myAge;
        //变量的初始化(赋值)
        myAge = 12;
        System.out.println(myAge);
        //2.变量的声明和初始化(赋值)
        int myNumber = 12;
        System.out.println(myNumber);
       //float
        float num1 = 12.3F; //小数点的数字默认是double类型，如果赋值给float,需要在值后面加上后缀f 大小写都OK
        System.out.println(num1);
        //double
        double num2 = 12.3;
        System.out.println(num2);
        //char
        char name = 'A';//字符类型的值必须使用单引号引起来，且只能有一个字符
        System.out.println(name);
        //boolean
        boolean flag = true;
        System.out.println(flag);
        //byte
        byte num3 = 12;
        System.out.println(num3);
        //short
        short num4 = 12;
        System.out.println(num4);
        //long
        long num5 = 12L; //整数数字默认是int类型，long类型的 变量的值后面可以添加L后缀，
        // 也可以省略（省略的时候暗含类型转换,但是不能超过int的范围，否则不能省略）
        System.out.println(num5);
        //String 
        String name1 = "weixu";//字符串类型的值必须使用双引号引起来
        System.out.println(name1);

3.5.3 控制台输入

        //控制台输入
        //1.导包 导入java.util.Scanner
        //2.创建对象
        Scanner sc = new Scanner(System.in);
        //3.调用方法 接收输入的数据
        int num = sc.nextInt();
        //4.打印输出
        System.out.println("num:"+num);
        input.close();//可以省略，避免有黄色的警告

3.5.4 变量的分类

基本数据类型变量
引用数据类型变量
按被声明的位置划分：

**局部变量：**方法或语句块内部定义的变量

**成员变量：**方法外部、类的内部定义的变量

特别注意：类的外面不能有变量的声明

/**
 *@ClassName:test6
 *@author weixu
 *@date 2023/7/17 19:23
 * 局部变量 成员变量
 * 
 * 局部变量：方法体中定义的变量，只在方法体中有效 
 * 生命周期：从声明开始到方法结束
 * 成员变量：类中方法外定义的变量
 * 生命周期：从对象创建开始，到对象被垃圾回收器回收
 *
 */
public class test6 {
    int a;//成员变量 赋值为0 不需要手动赋值
    public static void main(String[] args) {
      int b = 0;//局部变量 需要手动赋值才能使用 
        System.out.println(b);
        test6 test6 = new test6();
        System.out.println(test6.a);
    }
}

4. 运算符

4.1 算术运算符(++ 、–重要)

//算术运算符 +、-、*、/、%、++、--
int a = 10;
int b = 20;
System.*out*.println(a+b);
System.*out*.println(a-b);
System.*out*.println(a*b);
System.*out*.println(a/b);//整数相除，结果为整数
System.*out*.println(a%b);//取余
System.*out*.println(a++);//先使用后加 输出结果：a为10
System.*out*.println(++a);//先加后使用 输出结果：a为11
System.*out*.println(a--);//先使用后减
System.*out*.println(--a);//先减后使用
//需要注意的是，++和--只能用于变量，不能用于常量或表达式
short s = 10;
//s = s + 1; //编译错误 因为s+1是int类型，需要强制转换
s = (short) (s + 1); //正确 将s+1强制转换为short类型
s++; //正确
s += 1; //正确

需要注意的是：

1.i = i+1使用简单赋值运算符，i += 1使用复合赋值运算，复合赋值运算符会自动地将运算结果转型为其左操作数的类型。

2.a++是先执行当前语句的其他操作后+1 ，++a是先+1后执行当前语句

4.2 赋值运算符（+=重要）

赋值运算符作用是将一个值赋给一个变量，运算顺序从右到左。

4.3 关系运算符

关系运算符作用是比较两边的操作数，结果总是boolean型的。

4.4 逻辑运算符（短路与和与重要）

逻辑运算符用于对boolean
型结果的表达式进行运算，运算结果总是boolean型。

4.5 字符串连接运算符

String s="He" + "llo";//结果"Hello"
//"+"除了可用于字符串相连接，也能将字符串与其它的数据类型相连成一个新的字符串。
//如：
String s="x" + 123;// 结果"x123"

4.6 三目运算符

        //三目运算符    关系表达式?表达式1:表达式2   x？y：z
        // X为boolean类型表达式，先计算x的值，若为true，整个三目运算的结果为表达式y的值，否则整个运算结果为表达式z的值。
        int a = 10;
        int b = 20;
        int c = 30;
        int max = a > b ? a : b;

        test3 test3 = new test3();
        System.out.println(max);//a>b为false，整个运算结果为b的值

4.7 位运算符(重要)

位运算符对两个操作数中的每一个二进制位都进行运算位运算符功能：

按位取反 ~
按位与 &：a&b = a%(b-1)
按位或 |
按位异或 ^

移位运算符：

左移："a<<b; "将二进制形式的a逐位左移b位，最低位空出的b位补0
带符号右移："a>>b; "将二进制形式的a逐位右移b位，最高位空出的b位补原来的符号位

无符号右移："a>>>b;"将二进制形式的a逐位右移b位，最高位空出的b位补0

//位运算符 
    public static void BitwiseOperator(){
        //位运算符只能用于整数类型的变量
        //位运算符包括：~、&、|、^、>>、<<、>>>
        //~:按位取反
        //&:按位与
        //|:按位或
        //^:按位异或
        //>>:右移
        //<<:左移
        //>>>:无符号右移
        //位运算符的使用
        int a = 10;
        int b = 20;
        System.out.println(a&b);//按位与，相同为1，不同为0
        System.out.println(a|b);//按位或，相同为1，不同为0
        System.out.println(a^b);//异或，相同为0，不同为1
        System.out.println(~a);//按位取反
        System.out.println(a>>2);//右移相当于除以2的n次方
        System.out.println(a<<2);//左移相当于乘以2的n次方
        System.out.println(a>>>2);//无符号右移
    }

5. 程序的流程控制

任何简单或复杂的算法都可以由顺序结构、分支结构和循环结构这三种基本结构组合而成。

它们的共同点是都包含一个入口和一个出口，它们的每个代码都有机会被执行，不会出现死循环。

5.1 顺序结构

5.2 分支结构

分支结构又被称为选择结构，根据条件成立与否来执行操作。

5.2.1 基本选择结构 if

/*语法：
if(条件){
}
*/

5.2.2 if-else选择结构

/*语法：
if(条件){
条件成立执行的内容}else{
条件不成立执行的内容}
*/

5.2.3 多重选择结构

用处：适合解决连续区间问题。

5.2.3.1 语法结构

if(条件1){
//条件1成立的时候执行的条件
}else if(条件2){
//条件1不成立，条件2成立的时候执行的条件
}else if(条件3){
//条件1、2不成立，条件3成立的时候执行的条件
}......
else if(条件n){
//条件1到n-1不成立，条件n成立的时候执行的条件
}else{
//当以上的所有条件都不成立的时候执行的代码
}
/*
整个结构是一个整体，当一个条件成立并执行之后，整个结构就已经执行完毕；if块必须有；
else if块可以有一个，也可以有多个；else 可以有一个，也可以没有。*/

5.2.3.2 示例

如果高考成绩过700 清华， 600-700:重点本科 500-600：普通本科 300-500：专科其他：其他出路。

public static void main(String[] args) {
Scanner input=new Scanner(System.in);System.out.println("请输入你的分数：");
int score=input.nextInt();
if(score>700) {
System.out.println("去清华");} else if (score >= 600/* &&score<=700 */) {
System.out.println("重点本科");}else if (score >= 500/* &&score<=600 */) {
System.out.println("普通本科");} else if(score>=300) {
System.out.println("专科");}else {
System.out.println("其他出路！");}
}

5.2.4 switch结构

5.2.4.1 语法

 //swtich
        int i;
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的选择：");
        i = scanner.nextInt();
        //选择控制  选择2则只会执行2的代码
        switch (i){
            case 1:
                System.out.println("我选择的是1");
                break; //如果不加break代码则会接着往下执行
            case 2:
                System.out.println("我选择的是2");
                break;
            case 3:
                System.out.println("我选择的是3");
                break;
        }
        //不加break则会直接往下执行 若输入的是2，则会执行2和3的代码，输出：我选择的是2 我选择的是3
        //可以通过break进行巧用 如判断月份天数
        switch (i){
            case 1:
                System.out.println("我选择的是1");
            case 2:
                System.out.println("我选择的是2");
            case 3:
                System.out.println("我选择的是3");
        }
    }

5.2.4.2 巧用break的省略

多分支月份输出天数

public static void main(String[] args) {
Scanner input = new Scanner(System.in);// 根据用户输入的月份，输出当月的天数，不考虑平年闰年
System.out.println("请输入月份：");int month = input.nextInt();switch (month) {case 1:case 3:case 5:
case 7:
case 8:
case 10:
case 12:
System.out.println(month + "月共有31天！");break;
case 4:
case 6:
case 9:
case 11:
System.out.println(month + "月共有30天！");break;
case 2:
System.out.println(month + "月共有28天！");break;
default:
System.out.println("您输入的月份有误！");break;
}
}

5.2.5 嵌套选择结构

5.2.6 字符串比较相等

==比较内存地址
equlas比较内容

String str1="abc";
String str2=input.next();
System.out.println(str1==str2);System.out.println(str1.equlas(str2));

注意：在Object类中的equals方法的默认实现与==运算符的行为相同，即比较两个对象的引用地址，而不是内容。然而，许多Java类（如String、Integer、Double等）重写了equals方法，使其比较对象的内容，而不仅仅是引用地址。

6. 循环结构

循环结构是一种重复结构，如果条件成立，它会重复执行某一循环体，直到出现不满足的条件为止。
循环两个点：1、循环操作 2、循环条件

6.1 while循环

    public static void WhileTest()
    {
        //while循环 要避免死循环
        int num = 1;
        while (num <= 25)
        {
            System.out.print(num+"圈"+" ");
            num++;//迭代语句不能忘否则会出现死循环
        }
    }

6.2 do while循环

    public static void  DoWhile()
    {
        //do while循环
        int num = 1;
        do {
            System.out.print(num+"圈"+" ");
            num++;
        }while (num <= 25);//先执行一次循环体，再判断条件是否成立 成立则继续循环，不成立则退出循环

    }

6.3 for循环

 public  static  void  ForText()
    {
        //for循环 小技巧：fori是模板
        //执行顺序：1.执行初始化语句(int i = 1)
        // 2.执行循环条件(i <= 25)
        // 3.执行循环体 (system.out.println(i+"圈"))
        // 4.执行迭代语句 (i++)
        // 5.执行循环条件 (i <= 25)
        for (int i = 1; i <= 25; i++) {
            System.out.print(i+"圈"+" ");
        }
    }

6.4 循环结构中的关键字

6.4.1 break

跳出循环，循环结束，不再执行后面的代码。

public static void  BreakTest()
    {    Scanner scanner = new Scanner(System.in);
        int i = 0;
        do
        {
            i++;
            System.out.println("还能坚持吗？");
            char isok = scanner.next().charAt(0);
            if (isok == 'n')
            {
                System.out.println("跑步结束！");
                break;//跳出循环,循环结束，不再执行后面的代码
            }
            System.out.println("这是第"+i+"圈");
        }
        while (true);
    }

6.4.2 continue

跳出循环，但只是不再执行此次循环直接进入下次循环

 public static void  ContinueTest()
    {
           int i = 0;
           Scanner scanner = new Scanner(System.in);
           do {
               i++;
               System.out.println("需要补充水分吗？");
               char isok = scanner.next().charAt(0);
               if (isok == 'n')
               {
                   continue;//跳出循环,不在执行此循环,进入下次循环
               }
               System.out.println("补充水分成功");
           }
           while (true);
    }

6.5 三种循环的对比

循环	语法	特征	如果初始条件不成立	使用场合
while	while(循环条件){ //循环操作}	先判定后执行	循环一次都不执行	万能循环
do while	do{ //循环操作}while(循环条件);	先执行后判断	执行一次	对于先执行后判断的题目
for	for(循环变量定义;循环条件;循环变量的改变){ //循环操作}	先判定后执行	循环一次都不执行	循环次数固定的题目

6.6 嵌套循环

//嵌套循环
    public static void  NestingTest()
    {
        //嵌套循环
        for (int i = 1; i <= 5; i++) {
            System.out.println("外层循环"+i);
            for (int j = 1; j <= 5; j++) {
                System.out.println("内层循环"+j);
            }
        }
    }

白给是个技术活！

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
java基础自学

SUN公司为了抢占市场先机，在1991年成立了一个由詹姆斯·高斯林（James Gosling）领导，名为“Green”项目小组，目的是开发一种能够在各种消费性电子产品上运行的程序架构。1994年，项目小组看到了浏览器在未来的发展前景，于是决定将OaK应用于万维网。1995年，他们用OaK语言研发了一种能将小程序嵌入到网页中执行的技术——Applet，由于Applet不仅能嵌入网页，还可随同网页在网络上进行传输，这让无数的程序员看到了OaK这门语言，与此同时，OaK正式更名为Java。
复制链接

扫一扫