JavaSE的基础入门笔记!比较个人向,可能有些乱
看不懂的直接问就可以啦

前言

整理更新中

本部分 Java基础教程 正在整理编辑中,预计需要 9天 ,可能存在部分内容缺失,我在慢慢整理,会逐步放出…

以前版本的记录太朦胧,废话很多(现在的废话也多

然后就是,把教程写的美观些~,不会太单调(容易视觉疲劳)

再再再就是,很多地方写的太简单了,可能不太好理解

数组那部分全都是代码,感觉没人能看懂… 另外,面向对象部分实在是,太多了!!!!!

我还没想好是另外弄一个文档页来单独放面向对象,还是说直接就在这个页面写。毕竟面向对象必须要详细些。

可能因为懒而接着在这里写

当前进度

  • Java背景知识
  • 环境搭建、编译工具选择
  • 基础概念
  • 流程控制
  • 方法的创建使用及重载
  • 数组
  • 面向对象
  • 总结

代码资源

本教程中所有内容 均以代码形式上传到本人网盘中,免费提供下载

都是我边看边写的,甚至文章内部分内容还是我照着代码写的

直通车: MoYu-Pan | Java 密码:moyu233

Java的背景知识

上世纪C系列统治编程的时候,程序员被指针等折磨的死去活来 (现在我也被折磨的死去活来)

Java的开发,让程序员们倍感欣喜

用Java来制作软件界面有些丑 ,于是被嘲笑"只是个玩具"

后来几年,一些高端企业发现Java开发一些大型项目的三高特性

高血压,高血脂,高血糖 ,高可用、高性能、高并发

Java才逐渐开始普及。比如手机系统:安卓,就是借助Java开发

JDK、JRE、JVM

1

JDK: Java的开发环境

JRE: Java的运行环境

JVM: Java的一个虚拟机。相当于模拟一个CPU来处理Java相关内容。
JAVA可以跨平台使用的核心,在不同平台模拟虚拟机。

一个BUG, 一次编译,到处运行

大概了解一下三者关系就可以。

Java开发环境基础搭建

开发环境

JDK我这里安装的是JDK17。可以按照自己需求安装版本

JDK最新版下载:https://www.oracle.com/java/technologies/downloads/

开发工具

安装IDEA

IDEA官网: https://www.jetbrains.com/

分为旗舰版(收费)和社区版(免费),社区版用来个人开发Java已经够用了。

所以这里选择社区版

提示:安装时勾选记得勾选 .java选项

配置汉化

打开IDEA,左上角Fire(文件)-Setting(设置)-Plugin-搜索Chinese

下载简体中文汉化补丁。安装完毕重启即可。

注释、标识符、关键字

注释

Java中分有三种类型的注释

  • 单行注释
  • 多行注释
  • 文档注释

具体格式如下:

//单行注释
 
/*多行注释
  多行注释
  多行注释
*/
 
/**
*文档注释
*文档注释
*/

标识符和关键字

关键字:
2
关键字不能作为命名。比如:int public ,是不允许的。

标识符:

所有标识符都应该以字母 (A-Z、a-z)美元符号($),或 下滑符(_) 开头

所有标识符在首个字符之后,可以使用 字母(A-Z、a-z),美元符号($),或下滑符(_) 以及数字的混合。

标识符 可以使用中文(但不提倡)

例子:

  1. #ABC、1ABC、*ABC…不合法。

  2. A#abc、A*abc…不合法。

注意 :标识符是大小感敏感的。int MOYUint moyu 不是同一个数据

Java的数据类型及部分拓展

数据类型

Java中,所有变量都必须先定义,然后才能使用

//不定义进行使用
int a;
System.out.println(a);  //输出a的值
//定义进行使用
int a = 20;
System.out.println(a);  //输出a的值

变量声明格式。

type varName [=value] [{,varName[=value] }]
类型   名称   =  值   (使用,隔开,声明多个变量)

数据类型分为:基本数据类型、引用数据类型(后面会提到!)

基本数据类型

数值类型

整数型: 例如0、1、2、3的整数

byte: 8位,最大存储数据量是255,存放的数据范围是-128~127之间。

short: 16位,最大数据存储量是65536,数据范围是-32768~32767之间。

int: 32位,最大数据存储容量是2的32次方减1,数据范围是负的2的31次方到正的2的31次方减1。

long: 64位,最大数据存储容量是2的64次方减1,数据范围为负的2的63次方到正的2的63次方减1。

浮点型: 例如1.1、2.34、5.689…的小数

float: 32位,数据范围在3.4e-45~1.4e38,直接赋值时必须在数字后加上f或F。

double: 64位,数据范围在4.9e-324~1.8e308,赋值时可以加d或D也可以不加。

其他

字符类型: 可以定义 一个字符 。比如”H“

char: 16位,存储Unicode码,用单引号赋值。

布尔类型:

boolean:只有true和false两个取值。

//例子
public class MoYu {
    public static void main(String[] args){
        //整数型
        byte a=100;
        int b=10000;
        long c = 100L;//long类型末尾要加L
        short d =100;
        //浮点型
        float e= 0.35f;//float类型末尾需要加f
        double f=20.45;
        //字符型
        char m = 'A';//char类型要用单引号,而不是双引号.
        //字符串
        String n="摸鱼233";//String要用双引号。并且String是类,而不是关键字
        //非数值型
        boolean g = true;
    }
}

引用数据类型

这里只列一下,不展开讲,后面会提到

类: Class

接口:Interface

数组:Arry

类型转换

只讨论七种基本数据类型的转换!

该部分整理中

自动类型提升

一行说明白!

byte、char、short -> int -> long ->float -> double

整理中…

强制类型转换

可能导致精度损失

1.精度损失
2.精度不损失
3.精度损失(二进制)

整理中…

拓展

  • 1字节(Byte)=8位(bit)
  • 1KB( Kilobyte,千字节)=1024B
  • 1MB( Megabyte,兆字节)=1024KB
  • 1GB( Gigabyte,吉字节,千兆)=1024MB
  • 1TB( Trillionbyte,万亿字节,太字节)=1024GB 
    #浮点数型不能直接拿来比较计算(本身数据具有约分)
double a = 1.0/10;  //值为0.1
float b = 0.1f;   //值为0.1
System.out.println(a);//输出为0.1
System.out.println(b);//输出为0.1
System.out.println(a==b);//输出为false

转义字符
控制字符

  • ’ 单引号字符
  • \ 反斜杠字符
  • \r 回车
  • \n 换行
  • \f 走纸换页
  • \t 横向跳格
  • \b 退格
    Unicode转义字符: \u
//例子
char a='A'
System.out.println("\u0065");   //输出得到A
System.out.println((int)A);    //输出得到65
//Unicode格式:U0000、UFFFF

变量、常量、运算符

变量、常量

变量类型:类变量、实例变量、局部变量

作用域:变量可以作用的范围

运算符

基本运算符:

操作符 描述 例子
+ 加法 - 相加运算符两侧的值 A + B 等于 30
- 减法 - 左操作数减去右操作数 A – B 等于 -10
* 乘法 - 相乘操作符两侧的值 A * B等于200
/ 除法 - 左操作数除以右操作数 B / A等于2
% 取余 - 左操作数除以右操作数的余数 B%A等于0
++ 自增: 操作数的值增加1 B++ 或 ++B
-- 自减: 操作数的值减少1 B-- 或 --B

自加自减符

public class moYu{
    public static void main(String[] args){
        int a = 3;//定义一个变量;
        int b = ++a;//自增运算
        int c = 5;
        int d = --c;//自减运算
        System.out.println("进行自增运算后的值等于"+b);
        System.out.println("进行自减运算后的值等于"+d);
    }
}

关系运算符

下表为Java支持的关系运算符

表格中的实例整数变量A的值为10,变量B的值为20:

运算符 描述 例子
== 检查如果两个操作数的值是否相等,如果相等则条件为真。 (A == B)为假
!= 检查如果两个操作数的值是否相等,如果值不相等则条件为真。 (A != B) 为真
> 检查左操作数的值是否大于右操作数的值,如果是那么条件为真。 (A> B)为假
< 检查左操作数的值是否小于右操作数的值,如果是那么条件为真。 (A <B)为真
>= 检查左操作数的值是否大于或等于右操作数的值,如果是那么条件为真。 (A> = B)为假
<= 检查左操作数的值是否小于或等于右操作数的值,如果是那么条件为真。 (A <= B)为真
public class MoYu {
  public static void main(String[] args) {
     int a = 10;
     int b = 20;
     System.out.println("a == b = " + (a == b) );
     System.out.println("a != b = " + (a != b) );
     System.out.println("a > b = " + (a > b) );
     System.out.println("a < b = " + (a < b) );
     System.out.println("b >= a = " + (b >= a) );
     System.out.println("b <= a = " + (b <= a) );
  }
}
/*
输出结果如下
a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false
*/

位运算符

二进制运算:

A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011

假设整数变量 A 的值为 60 和变量 B 的值为 13:

操作符 描述 例子
如果相对应位都是1,则结果为1,否则为0 (A&B),得到12,即0000 1100
| 如果相对应位都是 0,则结果为 0,否则为 1 (A | B)得到61,即 0011 1101
^ 如果相对应位值相同,则结果为0,否则为1 (A ^ B)得到49,即 0011 0001
按位取反运算符翻转操作数的每一位,即0变成1,1变成0 (〜A)得到-61,即1100 0011
<< 按位左移运算符。左操作数按位左移右操作数指定的位数 A << 2得到240,即 1111 0000
>> 按位右移运算符。左操作数按位右移右操作数指定的位数 A >> 2得到15即 1111
>>> 按位右移补零操作符。左操作数的值按右操作数指定的位数右移,移动得到的空位以零填充。 A>>>2得到15即0000 1111

逻辑运算符

操作符 描述 例子
&& 称为逻辑与运算符。当且仅当两个操作数都为真,条件才为真 (A && B)为假
| | 称为逻辑或操作符。如果任何两个操作数任何一个为真,条件为真 (A | | B)为真
称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true,则逻辑非运算符将得到false。 !(A && B)为真。
拓展

短路逻辑运算

当使用 与逻辑运算符 时,在两个操作数都为true时,结果才为true,但是当得到第一个操作为false时,其结果就必定是false,这时候就不会再判断第二个操作了。

public class moYu{
    public static void main(String[] args){
        int a = 5;//定义一个变量;
        boolean b = (a<4)&&(a++<10);
        System.out.println("使用短路逻辑运算符的结果为"+b);
        System.out.println("a的结果为"+a);
    }
}
/*
使用短路逻辑运算符的结果为false
a的结果为5
*/

解释:  该程序使用到了短路逻辑运算符(&&),首先判断 a<4 的结果为 false,则 b 的结果必定是 false,所以不再执行第二个操作 a++<10 的判断,所以 a 的值为 5。

条件运算符

条件运算符也被称为 三元运算符 。该运算符有3个操作数,并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

int long = 10;
String one = (long<15)?"长度不合格":"长度合格";

运算符优先级

类别 操作符 关联性
后缀 () [] . (点操作符) 左到右
一元 expr++ expr– 从左到右
一元 ++expr --expr + - ~ ! 从右到左
乘性 * /% 左到右
加性 + - 左到右
移位 >> >>> << 左到右
关系 > >= < <= 左到右
相等 == != 左到右
按位与 左到右
按位异或 ^ 左到右
按位或 | 左到右
逻辑与 && 左到右
逻辑或 | | 左到右
条件 ?: 从右到左
赋值 = + = - = * = / =%= >> = << =&= ^ = | = 从右到左
逗号 左到右

包、JavaDoc

Java的包机制就如同电脑建文件夹一样,大概理解就好。
JavaDoc是java一种文档功能,可以视为一种说明书,不详细展开

官方JavaDoc示例:直通车

流程控制

总体内容比较简单,信息量少。可以去看下我写的代码,里面有一些应用

if、if…else条件判断

普通的IF语句

条件判断句式,(如果…,则…,否则)

if(布尔表达式)
{
   //如果布尔表达式为true将执行的语句
}

示例

//if势力
public class Demo {
 
   public static void main(String args[]){
      int x = 10;
 
      if( x < 20 ){
         System.out.println("摸鱼屋防伪!");
      }
   }
}

IF…Else语句

if 语句后面可以跟 else 语句,当 if 语句的布尔表达式值为 false 时,就会执行else内容

public class Demo {
 
   public static void main(String args[]){
      int x = 30;
      if( x < 20 ){
         System.out.println("这是 if 语句");
      }else{
         System.out.println("这是 else 语句");
      }//明白区别了吧
   }
}

注意:

  • if 语句至多有 1 个 else 语句,else 语句在所有的 else if 语句之后。
  • if 语句可以有若干个 else if 语句,它们必须在 else 语句之前。
  • 一旦其中一个 else if 语句检测为 true,其他的 else if 以及 else 语句都将跳过执行。

Switch选择结构

整理中整理中!!!!

while、do…while循环

基本的While

while是最基本的循环,就像这样:

while( 布尔表达式 ) {
  //循环内容
}

规则: 只要布尔表达式为 true,循环就会一直执行下去。
别写一个死循环啊喂!!(强调)
代码例子:

public class Demo {
   public static void main(String[] args) {
      int x = 10;
      while( x < 20 ) {
         System.out.print(x+"\n");
         x++;
      }//While结束~
   }
}

Do…While语句

while是,满足条件,进入循环,然后执行语句
do…while 则是,先执行一次语句,然后判断是否进入循环。

do {
    //代码语句
}while(布尔表达式);

注意: 布尔表达式在循环体的后面,所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为 true,则语句块一直执行,直到布尔表达式的值为 false

For循环

for循环是一个神奇的循环,很简单的结构,很简单的循环

但是稍微那么嵌套几个for,就很容易绕进去了

所以还是建议自己写几个小应用理解理解(比如:9x9乘法表)

或者去我网盘里下载一下看看

For循环

简单!

结构如下:

for(初始化; 布尔表达式; 更新代码) {
    //代码!
}

具体运行是:先初始化,然后判断布尔值,为true则结束,为false则执行代码
执行完代码后,执行更新代码。最后再判断布尔值,重复上述步骤
简单写个代码理解下

public class Demo {
    public static void main(String[] args) {
        //简单的for语句
        int a;
        for (a=1;a<10;a++) {
            System.out.println(a);
        }//for结束
     }
}

一定一定要去看应用!

增强For循环

这个结构就比较抽象了 (我真的讨厌这个!)

for(声明语句 : 表达式)
{
   //代码句子
}

是不是看不明白了。没事,写一个对比代码看一下就好
增强版可以理解为普通版的简化表达 (个人理解)

public class Demo {
    public static void main(String[] args) {
        //增强for循环
        int[] numbers = {10,20,30,40,50};
        for (int x : numbers){
            System.out.println(x);
        }
        //等效于
        for (int o=0;o<5;o++){
            System.out.println(numbers[o]);
        }//for结束
    }
}//代码结束

到这里流程控制就结束啦,也不知道我写明白没有
一定要记得去自己写写应用!


Java方法

终于到了一个稍微稍微重头戏的内容
这部分内容比较重要,和后面的许多内容都有关联!
加油!

方法创建及使用

最好自己开个IDEA跟着一起写写

方法的创建

Java方法 是语句的集合,它们在一起执行一个功能。

举个栗子:
解方程!

解方程 的过程 是 对未知数 求解
那我们设定一个 “解方程”方法,然后把解方程的内容写进去

现在“解方程“ 就是个方法。

那么现在你就可以 解方程(式子); 来解方程了

是不是有点太抽象了,简单写个 加法 的 方法吧

//加法算法
public static int add(int a,int b){
    int sum;
    sum = a+b;
    return sum;
}
 
 
/*
方法结构:
修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}
*/

你是不是疑惑!
“static是什么,public是什么,return又是什么啊,三个int分别什么意思啊?”
别急! (我知道你很急,但你先别急)
可以看到我在代码最下面写了方法的结构

public , static 都是修饰符,return 是返回值

public

表示这个方法是公开的。谁都可以调用的

static

表示这个方法是静态的

什么叫静态呢?
简单说就是,在你这个 类(Class) 刚开始执行的时候,方法就一同被创建好了,这样直接就可以在类内调用了

不加 static的话,只有当你代码里用到这个方法的时候,才会去创建方法。

为了理解,本块内容里所有方法都是静态的。非静态到面向对象会说的!

return

是返回值,会返回一个数据,这个数据的类型就是修饰符后写的数据类型

第一个int是返回值的数据类型
void 则表示无返回值。余两个 int 则是参数

方法的使用

会创建也要会用!
看个代码来简单理解下

public class Demo {
    //什么是方法
    //main方法
    //void表示返回空
    public static void main(String[] args) {
        int m=10;
        int n=20;
        int sum = add(m,n);//调用加法
        System.out.println(sum);
    }
    //构建有返回值的方法
    //加法
    //int 表示方法的返回数值类型
    //static表示是静态方法。类内可调用
    public static int add(int a,int b){
        return a+b;//返回add方法的值
    }

可以看到,我使用了 int sum = add(m,n);

括号内的两个参数的值会传递到方法里的a和b上,然后返回a+b的值,此时sum被赋值。完成了一次方法调用

方法内的a和b只是一个符号,是作为值传递的媒介,本身无法被方法外调用的。

比如英语里的that。可以拿来替代一个句子,但没有句子前提,本身拿出来是无意义的.

切记:返回值类型和你return后面的数据类型必须相同!

方法重载及可变参数

方法重载

那么问题来了,我写了一个add加法,返回类型是int,但是我需要对double进行一次加法,怎么办呢,写一个add2吗

答案是:方法重载

下面用一个简单的比大小方法做例子(不严谨的方法),只理解方法重载意思即可

public class Method1 {
    public static void main(String[] args) {//main方法
          int x = 10;
          int y = 15;
          double n = 22;
          double m = 25;
    }
    //比大小方法
    public static boolean bigger(int a,int b){
        return a>b;
    }
    //return在方法中表示方法结束
    //方法重载
    public static boolean bigger(double a,double b) {
        if (a-b<0){
            return false;
        }else{
            return true;
        }
    }

可以看到我创建了两个同名方法,但是参数类型却是不同的。这便是方法重载

当我的代码参数输入为两个 double 时,方法会自动选择到 double 的比大小

当我输入两个int时,方法会自动选择到int比大小

同名不同参 ,程序执行时,会自动选择适合你输入参数的方法。

可变参数

那么如果需要三个甚至多个数之间比大小,而方法add只写了两个参数,

这时候需要用到:可变参数

抽象的东西,还是直接上代码!

//可变参数
    //多个整数加减
    public static int add(int... i){
        int result = 0;
        int a=i.length ;
        for(int x=0;x<a;x++){
            result = result + i[x];
        }
        return result;
    }

int... i 表示这里可以填写多个 int 参数

而int i ,也就是可变参数,实际存储形式为数组(后面会讲),这时候想要把所有数加到一起,就需要用for循环遍历一下数组。

不懂也没关系,知道可变参数怎么写,什么意义即可
(不可能看不懂的吧!不可能的吧?)

值传递与引用传递

[整理中]

数组

又是一个稍微重头戏的内容!
加油,米娜桑

面向对象

总结

Sidere mens eadem mutato