后端开发学习日志（基础篇）

最新推荐文章于 2024-05-04 10:00:18 发布

Xiaoxian____

最新推荐文章于 2024-05-04 10:00:18 发布

阅读量187

点赞数

文章标签：学习后端

本文链接：https://blog.csdn.net/Xiaoxian____/article/details/125390538

版权

在正式学习前，我们需要像学习C、C++一样看一下Hello World的代码

public class Hello{
public static void main (string[] args) {
system. out.print ( "Hello, world ! " ) ;
   }
}

这可以帮助我们理解Java中的代码

基本数据类型(primitive type)

一、注释

平时我们编写代码，在代码量比较少的时候，我们还可以看懂自己写的，但是当项目结构一旦复杂起来，我们就需要用到注释了。注释并不会被执行，是给我们写代码的人看的书写。注释是一个非常好的习惯。在Java中，分别有以下三种注释：

1.单行注释

以双斜杠“//”标识，只能注释一行内容，用在注释信息内容少的地方。打开 IDEA，在 Java 代码中使用单行注释，以“HelloWorld"程序为例

public class HelloWorld {
    public static void main(String[] args) {
        //单行注释
        //输出HelloWorld
        System.out.println("HelloWorld");
       
    }
}

2.多行注释

包含在“/*”和“*/”之间，能注释很多行的内容。为了可读性比较好，一般首行和尾行不写注释信息，以“HelloWorld"程序为例

public class HelloWorld {
    public static void main(String[] args) {   
        System.out.println("HelloWorld");
        /*
        多行注释
        无论多少行
        在多行注释符号内
        都为注释内容
        */       
    }
}

注意：多行注释可以嵌套单行注释，但是不能嵌套多行注释和文档注释。

3.文档注释

包含在“/**”和“*/”之间，也能注释多行内容，一般用在类、方法和变量上面，用来描述其作用。注释后，鼠标放在类和变量上面会自动显示出我们注释的内容。目前处于新手学习阶段，使用较少，优先熟练使用单行注释和多行注释。

我们也以”HelloWorld"为例

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("HelloWorld");
        //JavaDoc:文档注释
        /**
         * @Description HelloWorld
         */
    }
}

二、标识符与关键字

关键字

Java关键字是一个保留字，具有与之相关的特殊含义。为了便于识别，它们通常用Java突出显示。

关键字

标识符

标识符（identifier）是指用来标识某个实体的一个符号，在不同的应用环境下有不同的含义。在计算机编程语言中，标识符是用户编程时使用的名字，用于给变量、常量、函数、语句块等命名，以建立起名称与使用之间的关系。标识符通常由字母和数字以及其它字符构成。

在Java中，我们需要注意以下几点：

1.所有的标识符都应该以字母（A-Z或者a-z）、美元符（$）、或者下划线（_)开始

2.首字符之后可以是字母（A-Z或者a-z）、美元符（$）、或者下划线（_)或数字的任何字符组合

3.不能使用关键字作为变量名或方法名

4.标识符是大小写敏感的

5.可以使用中文命名

合法标识符举例：acg、$money、_value、__1_value

非法标识符举例：123abc、-salary、#abc

中文命名：

String 段位 ="最强王者";

三、数据类型

在开始说明Java的数据类型前，我们需要简述一下强类型语言和弱类型语言。

强类型语言

即强制数据类型定义的语言。也就是说，一旦一个变量被指定了某个数据类型，如果不经过强制转换，那么它就永远是这个数据类型了。有以下几点需要注意：

1.如果你定义了一个整型变量 a，那么程序根本不可能将 a 当作字符串类型处理。

2.强类型定义语言是类型安全的语言。

3.当你定义一个变量是某个类型，如果不经过代码显式转换（强制转化）过，它就永远都是这个类型，如果把它当做其他类型来用，就会报错。

错误示范：

        String a ;
        System.out.println(a);

正确示范：

        String a = "lol";
        System.out.println(a);

弱类型语言

即数据类型可以被忽略的语言。它与强类型定义语言相反, 一个变量可以赋不同数据类型的值。你想把这个变量当做什么类型来用，就当做什么类型来用，语言的解析器会自动（隐式）转换。

Java属于强类型语言，它的数据类型共分为两大类：基本类型(primitive type)和引用类型(reference type)

基本数据类型(primitive type)

1）数据类型

1.整数类型

①byte占1个字节范围：-128-127

②short占2个字节范围：-32768-32767

③int占4个字节范围：-2147483648-2147483647

④long占8个字节范围：-9223372036854775808-9223372036854775807

2.浮点类型

⑤float占4个字节

⑥double占8个字节

3.字符类型

⑦char占2个字节

2）boolean类型

⑧占1位其值只有true和false两个

什么是字节

字节（Byte）是计算机信息技术用于计量存储容量的一种计量单位，也表示一些计算机编程语言中的数据类型和语言字符。

位(bit):是计算机内部数储存的最小单位，11001100是一个儿位二进制数。

字节(yte):是计算机中数据处理的基本单位，习惯上用大写B来表示。

1B (byte,字节) = 8bit(位)

字符:是指计算机中使用的字母、数字、字和符号。

1bit表示1位,
1Byte表示一个字节1B=8b
1024B=1KB
1024KB=1M1024M=1G

引用数据类型

1.类

2.接口

3.数组

数据类型扩展

整数拓展：

进制二进制0b 十进制八进制0 十六进制0x

int i = 10;
int i2 = 010;
int i3 = 0x10;
System.out.println(i);
System.out.println(i2);
System.out.println(i3);

输出结果为

10
8
16

讨论

float f = 0.1f是否等于double d =1.0/10?
float d1 = 0.1f是否等于float d2 = d1+1?

输入编程：

float f = 0.1f;
double d = 1.0/10;
System.out.println(f==d);
float d1 = 23131312312312313f;
float d2 = d1 + 1;
System.out.println(d1==d2);

得到结果为

false
true

原因

当我们用浮点类型float表示实数时，它是有限的和离散的，会产生舍入误差。舍入误差是指运算得到的近似值和精确值之间的差异，接近但不等于实际结果。使用时最好完全使用浮点数进行比较。

字符拓展：

输入编程：

char c1 = 'a';
char c2 = '中';
System.out.println( c1);
System.out.println( (int)c1);//强制转换
System.out.println(c2);
System.out.println( (int)c2);//强制转换

得到结果为：

a
97
中
20013

原因：所有的字符本质都是数字。在编码Unicode中它只占2个字节并可以表示65536字符，通过这些字符可以转换成其他文字。

char c3 = '\u0061';

输出结果为:

a

转义字符：

\t 制表符
\n 换行

布尔值拓展：

boolean flag = true;
if(flag==true){}

或者

boolean flag = true;
if(flag){}

其中

if(flag==true){}与if(flag){}等价

四、类型转换

由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。运算中不同类型的数据先转化为同一类型，然后进行运算。下面是容量从低到高排序

低 ----------------------------------------------------------高

byte,short,char—> int —>long—>float—>double

注意：float是32位但排在64位的long后面，是因为小数的优先级高于整数

我们输入以下代码：

        int a =128;
        byte b = (byte)a;
        System.out.println(a);
        System.out.println(b);

输出结果为：

128
-128

原因：byte内存最大值为127，128超出最大值，内存溢出。

在由高转低时，我们需要强制转换。

格式（类型）变量名

而由低转高时，编程会自动转换，无需加其他代码。

int a =128;
double b = a;

输出结果为：

128
128.0

若我们输入

        System.out.println((int)23.8);
        System.out.println((int)-45.36f);

结果为

23
-45

这是因为在前后精度并不一样，需要与int保持一致。

总结：

1.不能对布尔值进行转换

2.不能把对象类型转换为不相干的类型

3.在把高容量转换到低容量的时候，强制转换

4.转换过程中可能存在内存溢出或者精度问题

常见问题：

1.操作比较大的数的时候，注意溢出问题

int money = 10_0000_0000;

输出结果为：

1000000000

可以发现下划线_并没有被输出。这个特性可以使我们更加方便读出数字。

下面我们看一串代码：

        int money = 10_0000_0000;
        int years = 20;
        int  total = money*years;
        long total2 = money*years;
        long total3 = money*((long)years);

输出total、total2、total3，得到的答案分别为-1474836480、-1474836480、20000000000。

total输出的值为-1474836480是因为计算的时候数值已经溢出，最终得到的答案也自然为-1474836480。而total2为什么输出值也是-1474836480呢？在软件运行的时候，years是int类型，money也是int类型，计算结果是先转换为int类型再转化为long类型，在转化为long类型前已经数据溢出，此时我们将year提前转化为long，则输出数值正确。将money转化为long类型也是可以的。

五、变量

变量指可以变化的量，一般格式为

数据类型变量名 = 值；

type varName [=value] [{,varName[=value]}];

可以用逗号隔开来声明多个同类型变量

        int a,b,c;
        int a=1,b=2,c=3;//不建议这么写，建议分开写
        String name = "lol";
        char x = 'X';
        double pi = 3.14;

Java是一种强类型语言，每个变量都必须声明其类型。
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

变量有三种作用域，分别为类变量、实例变量、局部变量。

public class demo06 {
static int allClicks = 0;//类变量
String str = "hello world";//实例变量
public void method(){
int i = 0;//局部变量
}
}

为了更好说明三种变量，我们输入以下代码：

public class demo06 {

   
    //属性：变量

    //实例变量:从属于对象；如果不自行初始化，这个类型的默认值
    //布尔值：默认值为false
    //除了基本类型，其余默认值都是null
    
    String name;
    int age;

    //main方法
    public static void main(String[] args) {

        //局部变量:必须声明和初始化值
        int i = 10;
        System.out.println(i);

        //变量类型   变量名字 = new demo06();
        demo06 Demo06 = new demo06();
        System.out.println(Demo06.age);
        System.out.println(Demo06.name);

        //类变量 static
    }

    //其他方法
    public void add(){
    System.out.println(i);//该部分无法输出，因为i是局部变量
    }

}

常量（Constant）

常量是初始化（initialize)后不能再改变值，不会变动的值。所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

final 变量名 = 值；

final double PI = 3.14;

常量名一般使用大写字符。

我们输入以下代码

 static  final  double PI = 3.14;
    public static void main(String[] args) {
        System.out.println(PI);

输出结果为3.14。

注意：修饰符不分先后顺序。

将第一行改写成

final static double PI = 3.14

最终输出结果是不变的。

变量的命名规范

1.所有变量、方法、类名见名知意

2.类成员变量：首字母小写和驼峰原则：monthSalary 除了第一个单词以外，后面的单词首字母大写

3.局部变量：首字母小写和驼峰原则，和类成员变量一样

4.常量：大写字母和下划线：MAX_VALUE

5.类名：首字母大写和驼峰原则：Man，GoodMan

6.方法名：首字母小写和驼峰原则：run（），runRun（）

六、运算符

Java语言支持如下运算符

·算术运算符：+，-，*，/，%,++，--
·赋值运算符：=
·关系运算符：>，<，>=，==，!=instanceof
·逻辑运算符：&&，||，!
·位运算符：&，|，^，~，<<，>>，>>>(了解!!!)
·条件运算符： ?:
扩展赋值运算符：-+，-=，*=，/=

        int a = 10;
        int b = 20;
        int c = 30;
        int d = 40;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(double)b);

结果为：
false
true
false
true
1

        long a = 123165456121L;
        int b = 123;
        short c = 10;
        byte d =8;
        System.out.println(a+b+c+d);
        System.out.println(b+c+d);
        System.out.println(c+d);//int类型

结果为：
123165456262
141
18

        int a = 10;
        int b = 20;
        int c = 21;
        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);
        System.out.println(c%a);

结果为：
false
true
false
true
1

自增自减运算符

自增自减运算符为自增（++）和自减（--）。具体用法可以观察以下代码

        int a = 3;
        int b = a++;//执行完这行代码后先给b赋值a再自增
        System.out.println(a);
        int c = ++a;//执行完这行代码前a先自增再赋值给b
        System.out.println(a);
        
        System.out.println(b);
       
        System.out.println(c);

输出结果为：

4

5

3

5

幂运算

进行幂运算可使用math

        //幂运算 2^3
        double pow = Math.pow(2,3);
        System.out.println(pow);

输出结果为：

8

逻辑运算符

boolean a = true;
boolean b = false;

System.out.println("a && b:"+(a && b));//逻辑与运算：两个变量都为真，结果才为true
System.out.println("a || b:"+(a || b));//逻辑或运算：两个变量有一个为真，结果则为true
System.out.println("!(a && b):"+!(a && b));//如果为真则变为假，如果是假则变为真

位运算符

位运算符主要针对二进制，它包括了：“与”、“非”、“或”、“异或”。从表面上看似乎有点像逻辑运算符，但逻辑运算符是针对两个关系运算符来进行逻辑运算，而位运算符主要针对两个二进制数的位进行逻辑运算。下面详细介绍每个位运算符。

我们先假设

A=0011 1100

B=0000 1101

1．与运算符
与运算符用符号“&”表示，其使用规律如下：
两个操作数中位都为1，结果才为1，否则结果为0。

A&B=0000 1100

2．或运算符
或运算符用符号“|”表示，其运算规律如下：
两个位只要有一个为1，那么结果就是1，否则就为0。

我们依旧以A、B为例

A/B = 0011 1101

3．非运算符
非运算符用符号“~”表示，其运算规律如下：

如果位为0，结果是1，如果位为1，结果是0。

~B = 1111 0010

4．异或运算符
异或运算符是用符号“^”表示的，其运算规律是：
两个操作数的位中，相同则结果为0，不同则结果为1。

A^B = 0011 0001

5.左移运算符与右移运算符
左移运算符将运算符左边的对象向左移动运算符右边指定的位数。右移运算符是将运算符左边的对象向右移动运算符右边指定的位数。使用符号扩展机制，也就是说，如果值为正，则在高位补0，如果值为负，则在高位补1。
我们输入以下代码：

        System.out.println(2<<3);

该行代码表示2在二进制中向左移动三位。为了方便记忆，可以理解为左移是*2，右移是/2

扩展赋值运算符

当使用扩展运算符时，变量在参与赋值运算时会把结果自动强制转换为当前变量的类型。

        int a = 10;
        int b = 20;
        a+=b; //a = a+b
        a-=b; //a = a-b

        System.out.println(a);
        System.out.println(""+a+b);//结果进行拼接
        System.out.println(a+b+"");//结果继续计算再拼接

三元运算符

基本语法为

条件表达式？表达式1：表达式2；

x ? y : z

它的含义为如果条件表达式x为true，运算后的结果是表达式y，否则为z

        int score = 80;
        String type = score < 60 ? "不及格" : "及格";
        System.out.println(type);

输出结果为：

及格

运算符优先级

下表中优先级上行优先于下行

七、包机制

为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。
包机制的语法格式为：

package pk1[. pkg2[. pkg3...] ];

一般利用公司域名倒置作为包名。比如百度就会使用com.baidu.XXX来分包。我采用分包如下图所示：

为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包，使用“import”语句可完成次功能。

import package1[.package2...].(classname|*);

例如以下代码：

package com.xian.base.operator;


import java.util.Date;

public class Demo01 {
    public static void main(String[] args) {
     
        Date

我们可以看见import必须在 package com.xian.base.operator下方，否则程序会报错。

如果我们想导入其他包的类，那么我们可以输入

import com.xian.base.Demo01;

此时系统会报错，这是因为Demo01已经被定义过，在以后分包的时候注意包里面的名字不要重复。

八、Java Doc

Javadoc命令是用来生产自己API文档的。
参数信息

@author作者名
@version 版本号
@since 指明需要最早使用的JDK版本
@param参数名
@return返回值情况
@throws异常抛出情况

package com.xian.base;

/**
 * @author  xian
 * @version 1.0
 * since 8.0
 */
public class Doc {


String name;

   
    public String test(String  name){
        return name;
    }
}

我们随意定一个变量name，像上面代码输入，在String name下加上

/**

*/

系统会自动生成

     /**
     * 
     * @param name
     * @return
     */

我们改写一下倒数第四行的代码，抛出一个异常，

public String test(String  name) throws  Exception{

像上述打出注释符，结果为：

    /**
     *
     * @param name
     * @return
     * @throws Exception
     */

我们打开Doc的文件夹，用cmd指令调出该文件夹的窗口。

我们输入

java -encoding UTF-8 -charset UTF-8 Doc.java

我们可以看见以下文字

我们返回文件夹可以看见生成若干网页和文件

点击index网页可以进入主页

我们可以看见我们生成的JavaDos文档

如何使用IDEA生产JavaDos文档？

打开菜单栏中tools，点击Generate JavaDoc

注意command line argument一栏中需要填入

-encoding UTF-8 -docencoding UTF8 -charset UTF-8

点击生成键即可生成JavaDoc文档

Xiaoxian____

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
后端开发学习日志（基础篇）

新手学习Java，欢迎大佬们指出错误
复制链接

扫一扫

后端开发学习日志（基础篇）

一、注释

二、标识符与关键字

关键字

标识符

三、数据类型

强类型语言

弱类型语言

基本数据类型(primitive type)

1）数据类型

2）boolean类型

什么是字节

引用数据类型

数据类型扩展

整数拓展：

字符拓展：

转义字符：

布尔值拓展：

四、类型转换

五、变量

常量（Constant）

变量的命名规范

六、运算符

自增自减运算符

幂运算

逻辑运算符

位运算符

扩展赋值运算符

三元运算符

运算符优先级

七、包机制

八、Java Doc

如何使用IDEA生产JavaDos文档？

“相关推荐”对你有帮助么？