标签：强类型   xxx   val   标识   pytho   str   pre   设置   种类   

基本语法（一）

程序的基本结构

Java程序的基本形式

Java语言是面向对象的语言。Java程序主要以类的形式存在，也叫Class，类也是Java程序的最小程序单位。

Java程序要求所有执行语句、方法都必须放在类里。

最简单的Java程序：

class Hello {
}

在上面的 Hello 类中，只是一个空类的定义，没有任何的类成分，可以通过编译，但执行时会报错误提示。

因为规定某个类如果需要被解释器直接解释执行，需要包含 main() 程序入口方法，而且还要使用 public static 来修饰，返回值类型还要设置为void，另外此方法的参数还得是 String[] args 字符串数组。

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

将来，就算我们 Java 程序慢慢变复杂了，但对一个 Java 程序来讲，只需要在一个类中有一个作为“入口”的 main 方法就好，其他的类都会被 main()方法直接或者间接调用。

Java程序的运行机制

计算机高级语言按程序的执行方式有两种：编译型和解释型。

编译型：
有专门的编译器，针对不同的操作系统，将源代码直接编译成当前系统硬件执行的机器码，然后包装成当前系统能识别且可执行的程序格式。所生成的可执行性程序能够在特定的系统平台上运行，不受开发环境限制。如果是想在不同的系统平台上执行，就需要将源代码直接放到不同系统平台中的编译器里再度编译，方可执行。
常见的编译型语言有：C、C++、Swift、Kotlin、Objective-C 等等。

解释型：
有专门的解释器，对源程序逐行解释成当前系统平台的机器码并立即执行的语言。解释型语言，每次执行的时候，都需要进行一次编译，相当于把编译型语言中的编译和解释过程混合到一起同时完成。所以，它的效率比较低，还不能脱离解释器独立运行。但它的优点是，跨平台运行特别简单，只要对应的平台上有相关的解释器即可。
常见的解释型语言有：JavaScript、Ruby、Python 等等。

JVM初识

Java 语言非常特殊，Java 源程序也会经过编译，但编译后不会生成特定平台的机器码，而是会生成一种与平台无关的字节码文件。但字节码文件不可执行，如果要执行，需要使用 Java 解释型器来解释执行。所以，Java 程序的执行过程，必须经过先编译、后解释两个步骤。可认为，Java 语言既是编译型语言，也是解释型语言。

运行过程：

1. Java源文件(xxx.java)通过javac指令进行编译，得到字节码文件(xxx.class)。

2. 字节码文件通过java指令解释执行，字节码经过JVM(解释器)的处理后生成电脑可以直接执行的机器码，至此java程序才能得以正确运行。

编程规范

Java源文件的命名规则

• Java 程序的源文件的扩展名为：xxx.java

• 如果类使用 public 进行修饰，则文件名要和类名一致。一个 Java 源文件中，可以定义多个 class，相互之间完全独立，但一个类中只能有一个 public 修饰的类。

• 一般情况下，建议一个 Java 源文件，只定义一个 Java 类即可。而且，最好源文件名与 public 所修饰的类名一致。

Java语言的大小写问题

Java语言严格区分大小写，对大小写敏感。

Java语言规定的“关键字”单词全部都是小写的。

路径中的空格问题

文件夹命名时，文件夹名称千万不能有空格。（切记！！！切记！！！切记！！！）

main()方法问题

一个 Java 程序，如果要运行它的话，必须包含 main() 方法，具体格式如下：

public static void main(String[] args) {
  // 需要执行的代码语句
  System.out.println("hello lucaswangdev");
}

标识符

常见分隔符：

在 Java 语言中，常见的分隔符主要有：分号、花括号、方括号、圆括号、空格、圆点等。

分号

在写代码的时候，每一句代码的结束，都需要使用分号来标明。

System.out.println("每一句代码，都是用分号来结束的");

花括号

花括号，主要是用来定义一个代码块。代码块，指的就是使用“{”符号作为开始，和“}”符号作为结束，所包含的一

段代码，在逻辑上是一个整体。

{
  	System.out.println("I");
    System.out.println("Love");
    System.out.println("Java");
}

方括号

方括号，主要是用来访问数组元素，经常紧跟数组变量名，方括号中主要指定数组元素的索引值。

String[] names = {"张三", "李四", "王五"};
System.out.println(names[1]); // 李四

圆括号

• 定义方法的时候，可以用来声明所有的形参。

  public void setName(String name){...}
  

• 调用方法的时候，可以用来传递实参。

  setName("jiajia");
  

• 在计算的时候，提升计算的优先级。

  int num = 2 * (3 + 5);
  

• 对类型进行强制转换。

  int num2 = (int) 3.14;
  

空格

空格，主要用于分隔一条语句中的不同部分。

圆点

圆点，一般用作类/对象 和它的成员（包括成员变量、方法和内部类之间的分隔符），表明调用某个类或某个实例的指定成员。

标识符命名规则

标识符，主要是用于给程序中变量、类、方法命名的符号。Java 语言的标识符，必须以字母、下划线、美元符开头，后面可以跟任意数目的字母、数字、下划线和美元符。

在书写的时候，特别要注意大小写的问题。

具体书写规则如下：

1. 可以由字母、数字、下划线和美元符组成，其中不能以数字开 头。
2. 不能是 Java 关键字和保留字，但可以包含关键字和保留字。
3. 不能包含空格。
4. 只能包含美元符号，不能包含其他 @、#、% 等特殊符号。

约定：

1. 标识符要符合语义信息

2. 包名所有字母小写

3. 类名每个首字母大写其他小写

4. 变量和方法第一个单词小写第二个开始首字母大写

5. 常量所有首字母大写

关键字

Java 中的关键字，是一些具有特殊用途的单词，也叫 keyword。所有的关键字都是小写的，在书写的时候要特别注意。另外true 、false和null都不是关键字，而是特殊的直接量。

数据类型

数据类型分类

Java 语言是强类型语言，强类型主是指：

• 所有的变量，必须先声明，后使用；

• 指定的变量只能接类型与之匹配的值。

每个变量、每个表达式，在编译时，就已经被确定对应的类型。类型，能够限制一个变量能被赋的值，能够限制一个表达式可以产生的值，这就可以限制了在这些值上可以进行的一些操作和操作的意义。

语法格式：

type varName [= varValue];

int age;
String name = "lucaswangdev";

Java 支持的数据类型主要有两种：**基本数据类型 **和 引用数据类型。

基本数据类型

如何使用？

1. 当你表示整数时就用 int（年龄、商品数量等），如果是小数就用 double（商品价格、身高等）。
2. 当你表示时间数值、文件、内存大小（程序中以字节为单位统计大 小的）就用 long，对于那些较大的数据也使用 long。
3. 如果在 I/O 操作和网络编程中，涉及内容传递，或者编码转换时 使用 byte。
4. 如果在逻辑判断中，则需要使用 boolean 值作为判断条件，要么 true，要么 false。
5. 当你需要处理中文的时候，使用 char。

整型

整型主要指的是以下四种类型：byte、short、int、long。

【注意】在指定 long 型整数的时候，需要在这个整数值后增加字母 L，也可以是小写 l。

// 100为byte类型
byte num = 100;

// 777L为long类型
long bigNumber = 777L;

什么是变量？变量有什么用？

编程的本质，就是对内存中数据的访问和修改。程序所用的数据都会保存在内存中，开发者需要一种方式去访问或修改内存中的数据。

数据溢出会出现什么情况？

    public static void main(String[] args) {
        // 最大值和最小值
         int max = 2147483647;
         int min = -2147483647;
        // 最大值 +1
         System.out.println(max + 1);
        // 最小值 -1
         System.out.println(min - 1);
    }

// 解决方法1：		
public static void main(String[] args) {
    // 最大值和最小值
    long max = 2147483647;
    long min = -2147483647;
    // 最大值 +1
    System.out.println(max + 1);
    // 最小值 -1
    System.out.println(min - 1);
}

// 解决方法2：		
public static void main(String[] args) {
    // 最大值和最小值
    int max = 2147483647;
    int min = -2147483647;
    // 最大值 +1
    System.out.println(max + 1L);
    // 最小值 -1
    System.out.println(min - 1L);
}

字符型

字符型，一般用来表示单个的字符，并需要使用一对单引号（‘‘）包含起来。

字符型的三种表示形式：

• 指定单个字符，比如‘A’、‘1’、‘i’ 等。
• 指定转义字符，比如‘\n’、‘\r’ 等。
• 指定 Unicode 值，比如 ‘\uXXX’ 等。

常用转义字符：

• \b 退格
• \f 换页
• \n 换行
• \r 回车
• \t 下个tab
• \ ‘ 单引号 ‘
• \ " 双引号 "

浮点型

Java 的浮点类型有两种：float 和 double。

Double

Java 语言的浮点类型，默认是 double 类型，也可以在一个浮点数后加 d 或 D（不过没必要）。

double 是双精度浮点数，一个 double 类型的数值占 8 字节、64 位。

double 型数值，第 1 位是符号位，接下来的 11 位表示指数，再接下来 52位表示尾数。

Float

float 是单精度浮点数，一个 float 类型的数值占 4 字节、32 位。

float 型数值，第 1 位是符号位，接下来的 8 位表示指数，再接下来 23 位表示尾数。

如果想把一个浮点数当作 float 类型使用，则需要其后加上 f 或 F。

布尔型

布尔型，也叫 boolean 型，只有两个值：真（true）和假（false）。 boolean 类型的值或变量主要用作旗标来进行流程控制，常用在以下几种流程中：

• if 条件流程控制语句
• while 循环流程控制语句
• do…while 循环流程控制语句
• for 循环流程控制语句
• 三目运算

基本数据类型转换

自动类型转换

如果系统支持把某种基本类型的值直接赋给另一种基本类型的变量，这种方式就是自动类型转换。

就好比，有两个瓶子，将小瓶中盛满的水导入空着的大瓶子，不会溢出来。

int ii = 88;
// int ii 转float
float ff = ii;

byte bb = 5;
// byte转char会报错
char cc = bb;

// byte可以转换成double,输出 5.0
double dd = bb;
System.out.println(dd);

注意：

把任何基本类型的值 + 字符串值的时候，都会自动被转成字符串类型（引用数据类型）。

// 不管是什么数据类型，只要跟字符串相连，最终都变成字符串
String str = 6.66f + "";
System.out.println(str);
// 从左往右运算，打印 6Java
System.out.println(1 + 2 + 3 + "Java");
// 从左往右运算，全都转成字符串了，打印 Java123
System.out.println("Java" + 1 + 2 + 3);

自动转换：

// 一个整数，默认就是 int 类型
// 一个浮点数，默认就是 double 类型

// 左边是 long 类型，右边是默认的 int 类型，左右不一样
// 等号代表赋值，将右侧的int常量，交给左侧的long变量进行存储
// int -> long，符合了数据范围从小到大的要求
// 这一行代码发生了自动类型转换。
long num1 = 100;
System.out.println(num1);
System.out.println(Utils.getType(num1)); //class java.lang.Long

// 100 // 左边是double类型，右边是float类型，左右不一样
// float -> double，符合从小到大的规则
// 也发生了自动类型转换
double num2 = 2.5F;
System.out.println(num2); // 2.5
System.out.println(Utils.getType(num2)); //class java.lang.Double

// 左边是float类型，右边是long类型，左右不一样
// long --> float，范围是float更大一些，符合从 小到大的规则
float num3 = 30L;
System.out.println(num3); // 30.0
System.out.println(Utils.getType(num3)); // class java.lang.Float

强制类型转换

强制转换，类似将大瓶子的水直接导入一个空的小瓶中，会引起溢出，数据丢失。

强制转换：

//左边是int类型，右边是long类型，不一样
//long --> int，不是从小到大
//不能发生自动类型转换！
//格式：范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据;
int num = (int) 100L;
System.out.println(num);

// long强制转换成为int类型
int num2 = (int) 6000000000L;
System.out.println(num2);// 1705032704

// double --> int，强制类型转换
int num3 = (int) 3.99; // 3，这并不是四舍五入，所有的小数位都会被舍弃掉
System.out.println(num3);

// 这是一个字符型变量，里面是大写字母A
char c1 = ‘A‘; // 66，也就是大写字母A被当做65进行处理
System.out.println(c1 + 1);
// 计算机的底层会用一个数字（二进制）来代表字符A， 就是65
// 一旦char类型进行了数学运算，那么字符就会按照一 定的规则翻译成为一个数字

byte num4 = 40; // 注意！右侧的数值大小不能超过 左侧的类型范围
byte num5 = 50;
// byte + byte --> int + int --> int
int result1 = num4 + num5;
System.out.println(result1); // 90

short num6 = 60;
// byte + short --> int + int --> int
// int强制转换为short：注意必须保证逻辑上真实大小 本来就没有超过short范围，否则会发生数据溢出
short result2 = (short) (num4 + num6);
System.out.println(result2); // 100

类型判断

9种预定义的基本类型Class对象，8个基本类型和void，这些都有Java虚拟机创建的，并且具有相同的名称。

//public native boolean isPrimitive();

System.out.println(byte.class.isPrimitive()); // true
System.out.println(short.class.isPrimitive());// true
System.out.println(int.class.isPrimitive());// true
System.out.println(long.class.isPrimitive());// true
System.out.println(float.class.isPrimitive());// true
System.out.println(double.class.isPrimitive());// true
System.out.println(char.class.isPrimitive());// true
System.out.println(boolean.class.isPrimitive());// true
System.out.println(void.class.isPrimitive());

类型判断的方法：

//获取变量类型方法
public static String getType(Object object){
    return object.getClass().toString();
}

运算符

算术运算符

算术运算符主要是基本的数学运算：加、减、乘、除和求余等

// 加法
int a = 11;
int b = 12;
int sum = a + b;

//减法
int c = 15;
int d = 10;
int sub = c - d;

// 乘法
int e = 2;
int f = 3;
int multiply = e * f;

// 除法
int g = 18;
int h = 9;
int div = g / h;
System.out.println("div = " +div);

double i = 3.0;
double j = g / i;
System.out.println("j = " + j);

//如果除数是0.0，则得到正无穷大， Infinity
//如果除数是-0.0，则得到负无穷大， -Infinity
double k = g / 0.0;
System.out.println("k = " + k); // k = Infinity

// java.lang.ArithmeticException: / by zero
//int l = g / 0;
//System.out.println("l = " + l);

// 取余
// 前者除以后者，得到一个整除的结果后剩下的值就是余数
int m = 5;
int n = 2;
int o = m % n;
System.out.println("o = " + o);

// 对 0.0 求余，则得到非数
Object p = m % 0.0;
System.out.println("p = " + p);

自加和自减

自加，用 ++ 表示，它是单目运算符，只能操作一个操作数。自加运算符只能操作单个数值型（整型、浮点型等）的变量，不能操作常量或表达式。

运算符可以出现在操作数的左边，也可以出现在右边，但特别要注意，出现左边和右边的最终效果是不一样的。

如果把 ++ 放在左边，则先把操作数加 1；然后才把操作数放入表达式中运算。

如果把 ++ 放在右边，则先把操作数放入表达式中运算，然后才把操作数加1。

++a
a = a + 1;
return a;

a++
temp = a;
a = a + 1;
return temp;

x++ increments the value of variable x after processing the current statement.
++x increments the value of variable x before processing the current statement.

So just decide on the logic you write.
x += ++i will increment i and add i+1 to x. 
x += i++ will add i to x, then increment i.

例：

int a = 66;
// 先将 a 的值，放入表达式中进行运算，然后再给 a 加 1
int b = a++ + 10;
// 先将 a 加上 1，然后将新得到的值，再放入表达式中进行运算
int c = ++a + 10;
System.out.println("a = " + a); // 68
System.out.println("b = " + b); // 76
System.out.println("c = " + c); // 78

复杂数学运算

一般我们使用 java.lang.Math 类的工具方法来完成复杂的数学运算，比如有乘方、开方等。

Math 类中包含了非常多的静态方法，用于完成各种复杂的数学运算。

int a = 12;
// 乘方
double b = Math.pow(a, 10);
// 平方根
double c = Math.sqrt(a);
// 随机数
double d = Math.random();
// 三角函数：sin
double e = Math.sin(2.34);
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);
System.out.println("d = " + d);
System.out.println("e = " + e);
//        a = 12
//        b = 6.1917364224E10
//        c = 3.4641016151377544
//        d = 0.24282712973853993
//        e = 0.7184647930691261

特殊的 + 号

特别要注意，+ 号除了是加号以外，它还可以作为字符串的连接符运算符使用。

int year = 2020;
String str = "年";
System.out.println(year + str);

赋值运算符

Java 使用 = 号作为赋值符号，用于为变量指定变量值。

int a = 12; 
char b = ‘h’; 
boolean c = true; 
// 将变量 a 赋值给 d 变量 
int d = a;

特别要注意，赋值运算符是从右向左执行计算的，程序先计算得到 = 右边的值，然后将该值“交给” = 左边的变量，变量相当一个容器，可以接收被赋的值。

位运算符

&：按位与，当两位同时为 1 时才返回 1。

|：按位或，只要有一位为 1 即可返回 1。

~：按位非，单目运算符，将操作数的每个位（包括符号位）全部取反。

^：按位异或，当两位相同时返回 0，不同时返回 1。

<<：左移运算符，将操作数的二进制码整体左移指定位数，左移后右边空

出来的位以 0 填充。

>>：右移运算符，把第一个操作数的二进制码右移指定位数后，左边空出

来的位置以原来的符号位填充。

>>>：无符号右移运算符。把第一个操作数的二进制码右移指定的位数后，

左边空出来的位置，总是以 0 来填充。

比较运算符

主要用于判断两个变量或常量的大小，比较运算的结果是一个布尔值（true 或 false）。

>：大于

>=：大于等于

<：小于

<=：小于等于

==：等于。

如果进行比较的两个操作数，都是数值类型，即使它们的数据类型不同，只要它们的值相等，就会返回 true。

如果两个操作数都是引用类型，那么只有当两个引用变量的类型具有父子

关系时才可以比较，而且这两个引用必须指向同一个对象才会返回 true。

!=：不等于

逻辑运算符

&&：与，前后两个操作数必须都是 true 才返回 true，否则返回 false。

&：不短路与，作用与 && 相同，但不会短路。

||：或，只要两个操作数中有一个是 true，就可以返回 true，否则返回

false。

|：不短路或，作用与 || 相同，但不会短路。

!：非，只需要一个操作数，如果操作数为 true，则返回 true。

^：异或，当两个操作数不同时才返回 true，相同时返回 false。

System.out.println(6 > 3 && ‘7‘ > 22);
System.out.println(6 >= 7 || ‘h‘ > ‘b‘);
System.out.println(6 >= 7 ^ ‘h‘ > ‘b‘);
int a = 6;
int b = 12;
if (a > 3 | b++ > 12) {
    System.out.println("a 的值：" + a);
    System.out.println("b 的值：" + b);
}
int c = 6;
int d = 12;
if (c > 3 || d++ > 12) {
    System.out.println("c 的值：" + c);
    System.out.println("d 的值：" + d);
}

三目运算符

语法格式：

表达式 ? 满足条件返回此处的值 A : 不满足返回此处的值 B

规则：先对表达式求值，如果表达式返回 true，返回 A 处的值；如果表达式返回 false，则返回 B 处的值。

int a = 6;
int b = 9;
System.out.println(a > b ? "a 比 b 大" : "a 比 b 小");

注释

在编程的时候，建议要添加一些注释，可以当作是某段代码的说明性文字，或者某个类的用途，某个方法有什么功能等。

单行注释，使用双斜杠“//”表示，在需要注释的语句最前面添加即可实现注释。

// 这是单行注释 
// System.out.println(“注释之后的语句，不能再被执行了”); 

多行注释，可以一次性将多行内容全都注释了。主要是以 /* 作为开头，*/作为结尾，将需要被注释的内容包含其中即可。

/*
我可以注释很多内容 System.out.println(“Hello World”); 
*/

Java基本语法-B2

标签：强类型   xxx   val   标识   pytho   str   pre   设置   种类   

原文地址：https://www.cnblogs.com/lucaswangdev/p/12688805.html