JavaSE的基础入门笔记!比较个人向,可能有些乱

看不懂的直接左下角发消息问就可以啦

#前言

我在学Java过程中,顺手写了一些代码。(写批注了)。有兴趣可以看看

文件已经上传至 个人网盘/JavaSE源码 文件夹内,可供下载

很可能代码更新了,笔记没有更新(懒...)

截止到2022-4-1 JavaSE我已经看完了,真谈上学习也就1个月,只不过穿插了打游戏(
大体框架(标题)已经更好了,会慢慢写完的

编译运行前请将顶部该类代码删除

package top.moyu.study.xxxxxx;//xxx代表一个字符,比如base

直通车:JavaSE源码

文件最新更新:2022/4/10 内容:数组

#Java的发展

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

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

但是用Java来制作软件界面有些丑?(如果我没记错的话)

于是被嘲笑“只是个玩具

后来几年,一些高端企业发现Java开发一些大型项目的三高特性:高血压,高血脂,高血糖,高可用、高性能、高并发

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

大概就这样?没什么用,了解一下可以用来得瑟。


#JDK、JRE、JVM

(图片来自:西部开源)

JDK:Java的开发环境

JRE:Java的运行环境

JVM:Java的一个虚拟机。相当于模拟一个CPU来处理Java相关内容。

批注:这个JVM,似乎就是JAVA可以跨平台使用的核心?在不同平台模拟虚拟机。一个BUG, 一次编译,到处运行

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


#Java开发环境基础搭建

开发环境

JDK我这里安装的是JDK17。

JDK最新版下载:Java 下载|神谕 (oracle.com)

开发工具

目前主流基本分为两种。我当初入坑时,是使用Eclipse的。

总结了一下两种开发工具:

Eclipse:提供各种语言支持,提供Java一站式服务。缺点:JDK比较滞后,容易出现版本问题

IDEA:美观高效。缺点是比较吃配置

看了下众多评价,我这里还是选择用IDEA了.

IDEA官网:IDEA官网

分为旗舰版(收费)和社区版(免费)

社区版用来开发Java已经够用了。

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

配置汉化:

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

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


#Hello,World!

 "hello,world"是The C Programming Language 中的第一个演示程序输出的句子

无数小白都是从hello,world开始写起。

输出hello,world的句子:

public class hello {
    public static void main(String[] args){
        System.out.println("hello.world");
    }
}

#注释、标识符、关键字

注释

Java中分有三种类型的注释

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

/*多行注释
  多行注释
  多行注释
*/

/**
*文档注释
*文档注释
*/

标识符和关键字

关键字:

(图片来源-西部开源)

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

标识符:

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

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

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

例子:

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

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] }]
类型   名称  =  值   (使用,隔开,声明多个变量)

数据类型分为:基本数据类型、引用数据类型(暂时不学)

非数值类型

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

数值类型

整数型:例如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也可以不加。

字符类型:可以定义为一串文字。比如”Hello,World“

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

//例子
public class hello {
    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;
    }
}

拓展

  • 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 等于 21
--自减: 操作数的值减少1 B-- 或 --B 等于 19

自加自减符

自加:++

自减:++

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示例:直通车


#流程控制

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

直通车:JavaSE源码

if、if...else条件判断

普通的IF语句

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

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

示例

public class If {
 
   public static void main(String args[]){
      int x = 10;
 
      if( x < 20 ){
         System.out.println("这是 if 语句");
      }
   }
}

IF...Else语句

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

代码示例

public class If {
 
   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 语句都将跳过执行。

while、do...while循环

普通的WHILE

while是最基本的循环,

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

规则:只要布尔表达式为 true,循环就会一直执行下去。

代码例子

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

      }
   }
}

Do....While语句

while是,满足条件,进入循环,然后执行语句

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

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

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

for循环

普通For循环

待更新(懒)

增强For循环

待更新(同上)(太简单了,可能最后才更)


#JAVA方法

[整理编辑中.....]

方法创建及使用

方法的创建

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

举个栗子:求导。求导的过程是把式子带入,然后通过求导公式把式子导出来

现在求导就是个方法。然后我们把所有求导公式全部写进求导方法里,这样遇到什么式子都能求出导

那么现在你就可以 求导(式子); 来方便求导了

下面写一个简单的加法方法

//加法算法
public static int add(int a,int b){
    int sum;
    sum = a+b;
    return sum;
}


/*
修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}
*/

>你可能会疑惑

"static是什么,public是什么,return又是什么啊,三个int分别什么意思啊?"

public,static都是修饰符,public表示这个方法是公开的。static表示这个方法是静态的

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

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

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

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

第一个int是返回值的数据类型,void则表示无返回值。余两个int则是参数,往下看你就明白了

方法的使用

那么怎么使用方法呢?看个代码来简单理解下

public class basis {
    //什么是方法
    //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循环遍历一下数组。

不懂也没关系,知道可变参数怎么写,什么意义即可

值传递与引用传递

[整理中...]


#数组

(预计4月20日前更完)

数组及使用

待更新

Arrays工具类

待更新

冒泡排序和稀疏数组

待更新


#面向对象

(预计5月前更完)

类、对象创建以及构造器


#总结

待更新(预计可能会删除。)


摸鱼ing