1-1 Java后端开发系列博客之基础语法（基础篇）

最新推荐文章于 2022-02-15 15:30:30 发布

printf("dream");

最新推荐文章于 2022-02-15 15:30:30 发布

阅读量253

点赞数

分类专栏： Java后端开发文章标签： Java 基础语法

本文链接：https://blog.csdn.net/qq_41278826/article/details/103101488

版权

Java后端开发专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Java的基础语法

Java简单介绍
基本设计结构

1、Java的简单介绍

Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。
Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。

2、基本设计结构

2.1 注释

类似于 C/C++、Java 也支持单行以及多行注释。注释中的字符将被 Java 编译器忽略。

/* 
* 1.这是一个多行注释的示例
*/
// 2.这是单行注释的示例
/* 这个也是单行注释的示例 */
/** 3.文档注释 */

2.2 数据类型

Java 的两大数据类型:

内置数据类型
引用数据类型

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。
2.2.1：整型

表2-1 Java整型

类型	存储需求	取值范围	默认值
int	4字节	-2147483648(-2³¹)~2147483647(2³¹-1) (正好超过20亿)	0
short	2字节	-32768(-2¹⁵)~32767(2¹⁵-1)	0
long	8字节	-9223372036854775808(2⁶³)~9223372036854775807(2⁶³-1)	0L
byte	1字节	-128(2⁷)~127(2⁷-1)	0

2.2.2：浮点型

表2-2 Java浮点型

类型	存储需求	取值范围	默认值
float	4字节	大约±3.40282347E+38F(有效位数为6~7为)	0.0f
double	8字节	大约±1.79769313486231570E+308(有效位数为15位数)	0.0d

2.2.3：字符型

char类型是一个单一的 16 位 Unicode 字符；
最小值是 \u0000（即为0）；
最大值是 \uffff（即为65,535）；
char 数据类型可以储存任何字符；
例子：char letter = ‘A’;。

2.2.4：布尔型

boolean数据类型表示一位的信息；
只有两个取值：true 和 false；
这种类型只作为一种标志来记录 true/false 情况；
默认值是 false；
例子：boolean one = true。

2.2.5：默认值

//关于默认值的示例
public class Lizi {
    static boolean bool;
    static byte by;
    static char ch;
    static double d;
    static float f;
    static int i;
    static long l;
    static short sh;
    static String str;

    public static void main(String[] args) {
        System.out.println("Bool :" + bool);
        System.out.println("Byte :" + by);
        System.out.println("Character:" + ch);
        System.out.println("Double :" + d);
        System.out.println("Float :" + f);
        System.out.println("Integer :" + i);
        System.out.println("Long :" + l);
        System.out.println("Short :" + sh);
        System.out.println("String :" + str);
    }
}
/*
//运行结果：
	Bool :false
	Byte :0
	Character: 
	Double :0.0
	Float :0.0
	Integer :0
	Long :0
	Short :0
	String :null
*/

注意事项：

Java中的默认类型：整数类型是 int 、浮点类型是double
数据范围与字节数不一定相关，例如float数据范围比 long 更加广泛，但是float是4字节，1ong是8字节。
浮点型可能只是一个近似值，并非精确的值。
浮点数当中默认类型是double。如果一定要使用float类型，需要加上一个后缀F。
字符串不是基本类型，而是引用类型。
如果是整数，默认为int类型，如果一定要使用long类型，需要加上一个后缀L。推荐使用大写字母后缀。

2.2.7：引用数据类型

在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
对象、数组都是引用数据类型。
所有引用类型的默认值都是null。
一个引用变量可以用来引用任何与之兼容的类型。
例子：Site site = new Site(“Runoob”)。

2.2.8：常量
常量在程序运行时是不能被修改的。
在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似：

final double PI = 3.1415927;

虽然常量名也可以用小写，但为了便于识别，通常使用大写字母表示常量。
2.2.9：转义字符

2.2.10：自动类型转换
整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。
转换从低级到高级。

低 ------------------------------------> 高
byte,short,char—> int —> long—> float —> double

数据类型转换必须满足如下规则：

不能对boolean类型进行类型转换。
不能把对象类型转换成不相关类的对象。
在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
转换过程中可能导致溢出或损失精度。
浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入。

2.2.11：强制类型转换

条件是转换的数据类型必须是兼容的。
格式：(type)value type是要强制类型转换后的数据类型

2.3 标识符和关键字

2.3.1 标识符
java中所有命名的位置所用的都是标识符。
命名规则:

由字母数字 _(下划线) ＄组成不能以数字开头
严格区分大小写大小写视为不同名字 ( java是一种强类型语言 )
标识符不能用关键字

命名规范:

见名知意即可不要过长
camel 驼峰原则
包的命名:全部小写多级包用 . 隔开例如:teng.xun
类||接口: 每个单词的首字母大写例如:JingDong
方法||变量: 第一个单词全部小写,第二个单词开始,每个单词首字母大写 taoBao
常量:全部大写每个单词之间使用 _ 进行分割 GUO_WU_YUAN

2.3.2 关键字:
Java里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。
所有的关键字都是小写, IDE中颜色存在不同显示。
具体可参考：Java中50个关键字和关键字的意思
注：随着版本的升级，关键字可能会变化。

2.4 变量

Java语言支持的变量类型有：

类变量：独立于方法之外的变量，用 static 修饰。
实例变量：独立于方法之外的变量，不过没有 static 修饰。
局部变量：类的方法中的变量。

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

2.5 修饰符

Java语言提供了很多修饰符，主要分为以下两类：

访问修饰符
非访问修饰符

2.5.1访问控制修饰符
Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部类）。

我们可以通过以下表来说明访问权限：
2.5.2 非访问修饰符
为了实现一些其他的功能，Java 也提供了许多非访问修饰符。
static 修饰符，用来修饰类方法和类变量。
final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
abstract 修饰符，用来创建抽象类和抽象方法。
synchronized 和 volatile 修饰符，主要用于线程的编程。
具体可参考：菜鸟教程。

2.6 运算符

表2-3 算术运算符

操作符	描述
+	加法：相加运算符两侧的值
-	减法：左操作数减去右操作数
*	乘法：相乘操作符两侧的值
/	除法：左操作数除以右操作数
%	取余：左操作数除以右操作数的余数
++	自增：操作数的值增加1
–	自减：操作数的值减少1

public class Lizi {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;
        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) );
        System.out.println("c % a = " + (c % a) );
        System.out.println("a++   = " +  (a++) );
        System.out.println("a--   = " +  (a--) );
        // 查看  d++ 与 ++d 的不同
        System.out.println("d++   = " +  (d++) );
        System.out.println("++d   = " +  (++d) );
    }
}
/*
//运行结果：
	a + b = 30
	a - b = -10
	a * b = 200
	b / a = 2
	b % a = 0
	c % a = 5
	a++   = 10
	a--   = 11
	d++   = 25
	++d   = 27
/*

表2-4 关系运算符

操作符	描述
==	检查如果两个操作数的值是否相等，如果相等则条件为真。
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。
>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。

public class Lizi {
    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
*/

表2-5 位运算符

操作符	描述
＆	如果相对应位都是1，则结果为1，否则为0
\|	如果相对应位都是 0，则结果为 0，否则为 1
^	如果相对应位值相同，则结果为0，否则为1
~	按位取反运算符翻转操作数的每一位，即0变成1，1变成0。
<<	按位左移运算符。左操作数按位左移右操作数指定的位数。
>>	按位右移运算符。左操作数按位右移右操作数指定的位数。
>>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。

public class Lizi {
    public static void main(String[] args) {
        int a = 60; /* 60 = 0011 1100 */
        int b = 13; /* 13 = 0000 1101 */
        int c = 0;
        c = a & b;       /* 12 = 0000 1100 */
        System.out.println("a & b = " + c );

        c = a | b;       /* 61 = 0011 1101 */
        System.out.println("a | b = " + c );

        c = a ^ b;       /* 49 = 0011 0001 */
        System.out.println("a ^ b = " + c );

        c = ~a;          /*-61 = 1100 0011 */
        System.out.println("~a = " + c );

        c = a << 2;     /* 240 = 1111 0000 */
        System.out.println("a << 2 = " + c );

        c = a >> 2;     /* 15 = 1111 */
        System.out.println("a >> 2  = " + c );

        c = a >>> 2;     /* 15 = 0000 1111 */
        System.out.println("a >>> 2 = " + c );
    }
}
/*
//运行结果：
	a & b = 12
	a | b = 61
	a ^ b = 49
	~a = -61
	a << 2 = 240
	a >> 2  = 15
	a >>> 2 = 15
*/

表2-6 逻辑运算符

操作符	描述
&&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。
\| \|	称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。
！	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。

public class Lizi {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        System.out.println("a && b = " + (a&&b));
        System.out.println("a || b = " + (a||b));
        System.out.println("!(a && b) = " + !(a && b));
    }
}
/*
//运行结果：
	a && b = false
	a || b = true
	!(a && b) = true
*/

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

表2-7 赋值运算符

操作符	描述
=	简单的赋值运算符，将右操作数的值赋给左侧操作数
+=	加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数
-=	减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数
* =	乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数
/ =	除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数
(%)=	取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数
<< =	左移位赋值运算符
>> =	右移位赋值运算符
＆=	按位与赋值运算符
^ =	按位异或赋值操作符
\| =	按位或赋值操作符

public class Lizi {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 0;
        c = a + b;
        System.out.println("c = a + b = " + c );
        c += a ;
        System.out.println("c += a  = " + c );
        c -= a ;
        System.out.println("c -= a = " + c );
        c *= a ;
        System.out.println("c *= a = " + c );
        a = 10;
        c = 15;
        c /= a ;
        System.out.println("c /= a = " + c );
        a = 10;
        c = 15;
        c %= a ;
        System.out.println("c %= a  = " + c );
        c <<= 2 ;
        System.out.println("c <<= 2 = " + c );
        c >>= 2 ;
        System.out.println("c >>= 2 = " + c );
        c >>= 2 ;
        System.out.println("c >>= 2 = " + c );
        c &= a ;
        System.out.println("c &= a  = " + c );
        c ^= a ;
        System.out.println("c ^= a   = " + c );
        c |= a ;
        System.out.println("c |= a   = " + c );
    }
}
/*
//运行结果：
	c = a + b = 30
	c += a  = 40
	c -= a = 30
	c *= a = 300
	c /= a = 1
	c %= a  = 5
	c <<= 2 = 20
	c >>= 2 = 5
	c >>= 2 = 1
	c &= a  = 0
	c ^= a   = 10
	c |= a   = 10
*/

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

表达式?值1:值2
如果表达式为真返回值1
如果表达式为假返回值2

variable x = (expression) ? value if true : value if false

instanceof 运算符
该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。
instanceof运算符使用格式如下：

( Object reference variable ) instanceof  (class/interface type)

如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)的一个对象，那么结果为真。
Java运算符优先级:
我认为这部分并不重要，实际编程中我们更喜欢用小括号来控制优先级。所以这部分我不做详细说明。大家如果有兴趣则参考：菜鸟教程。

printf("dream");

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
1-1 Java后端开发系列博客之基础语法（基础篇）

Java的基础语法Java简单介绍基本设计结构注释基本数据类型标识符关键字变量运算符字符串数组控制流程继承接口对象与类异常其它1、Java的简单介绍 Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，...
复制链接

扫一扫