文章目录

• • 1、java的基础程序设计结构
  • • • 1.1、一个简单的 java 应用程序
      • 1.2、java命名规范
      • 1.3、注释
      • 1.4、数据类型
      • • 1.4.1、整型
        • 1.4.2、浮点类型
        • 1.4.3、char 类型
        • 1.4.4、boolean 类型
      • 1.5、变量与常量
      • • 1.5.1、声明变量
        • 1.5.2、变量初始化
        • 1.5.3、常量
        • 1.5.4、枚举类型
      • 1.6、运算符
      • • 1.6.1、算术运算符
        • 1.6.2、数学函数与常量
        • 1.6.3、数值类型之间的转换
        • 1.6.4、强制类型转换
        • 1.6.5、结合赋值和运算符
        • 1.6.7、自增与自减运算符
        • 1.6.8、关系和 逻辑 运算符
        • 1.6.9、三元运算符
        • 1.6.10、位运算符
        • 1.6.11、括号与运算符级别
      • 1.7、字符串
      • • 1.7.1、子串
        • 1.7.2、拼接
        • 1.7.3、不可变字符串
        • 1.7.4、检测字符串是否相等
        • 1.7.5、空串与 Null 串
        • 1.7.6、码点与代码单元
        • 1.7.7、String API
        • 1.7.8、构建字符串

1、java的基础程序设计结构

1.1、一个简单的 java 应用程序

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

​ 注意 ：java区分大小写，如果大小写拼写错误（例如：将 main 拼写成 Main），程序将无法运行，java的大括号都是一 一对应的，打代码时应该两个大括号一起打出来然后回车。

​ 逐一分析这段代码：
​ 1、public关键字 ：称为访问修饰符，这些修饰符用于控制程序的其他部分对这段代码的访问级别。

​ 2、class关键字 : 表明 java 程序用的全部内容都包含在类中。

​ 3、Hello : 表示类名，可以随意修改，须符合命名规范，不能是关键字。

​ 4、static关键字 ： static关键字可以用来修饰代码块表示静态代码块，修饰成员变量表示全局静态成员变量，修饰方法表示静态方法。被static关键字修饰的内容都是静态的。

​ 5、void关键字 ： 表示方法的返回值类型，可更改为其他的数据类型，void表示没有返回值。

​ 6、main ： 方法名，main方法是整个程序的入口方法，是一个比较特殊的方法，括号里面的是main方法的参数，main方法括号里面放了一个String类型的数组参数，如有需求可在编译的时候赋值。

​ 7、main方法里面的是java的输出语句用于向控制台输出，使用了 System.out 对象并调用了它的 println 方法。

1.2、java命名规范

​ java的命名应：类名是以大写字母开头的名词。如果名字由多个单词组成，每个单词的第一个字母都应该大写（这种在一个单词中间使用大写字母的方式称为骆驼命名法（camel case）。以其自身为例，应该写成 CamelCase）
代码的文件名必须与public修饰的类名相同，并且public修饰的类只能有一个，并用 .java 作为扩展名。

1.3、注释

public class Hello{
    /**这是文档注释*/
    public static void main(String[] args){
       	//这是单行注释
        
        /*
        这是多行注释
        */
    }
}

单行注释：只能一行， //后面区域为注释区域

多行注释：可以多行，/*里面的为注释区域，可以多行*/

文档注释： 可以多行，/**这里面为注释区域，可以多行*/

注释： java程序执行的时候不会执行注释里面的内容，单行注释或多行注释可用于说明或解释某段程序，文档注释可以用来描述 某个类或方法 可以使用 Javadoc 工具生成信息，并且输出解释文件

1.4、数据类型

​ java 是一种强类型语言。这就意味着必须为每一个变量声明一种类型。在java中，一共有8种基本类型、其中4种整型、2种浮点类型、1种字符类型 char（用于表示 Unicode 编码的代码单元）

1.4.1、整型

​ 整型用于表示没有小数部分的数值，允许是负数。java提供了 4 种整型

​ 通常情况下，int 类型最常用。如果你想要表示整个地球的居中人口，就需要使用 long 类型。byte 和 short 类型主要用于特定的应用场合。

​ 在 java 中，整型的范围与运行 java 代码的机器无关。这就解决了软件从一个平台移植到另一个平台，或者在同一个平台中的不同操作系统之间进行移植给程序员带来的诸多问题。

​ 长整数数值（long）使用时需要一个后辍 L 或 l （如 1433223L）

1.4.2、浮点类型

​ 浮点类型用于表示有小数部分的数值。在 java中有两种浮点类型。

​ double 表示这种类型的数值精度是 float 类型的两倍（有人称之为双精度浮点数）。一般情况下，double类型最常用。

​ 如果想用float 类型的数值需要加后辍 F 或 f（如 3.14F） 。如果不加 F 或 f 的话（如 3.14）java会默认为double类型

1.4.3、char 类型

​ char 类型的字面量值要用单引号括起来。例如：‘A’ 是编码值为 65 的字符常量。它与 “A” 不同，“A” 是包含一个字符串 A 的字符串。char 类型的值可以表示十六进制值，其范围从 \u0000 到 \uFFFF。例如，\u2122表示商标符号（™）

​ 除了转义序列\u 之外，还有一些用于表示特殊字符的转义序列：

1.4.4、boolean 类型

​ boolean（布尔）类型有两个值：false 和 true，用来判定条件。整数值和布尔值之间不能进行相互转换。

1.5、变量与常量

​ 使用变量来存储值。常量就是值不变的变量。

1.5.1、声明变量

​ 在java中，每个变量都有一个类型。在声明变量时，先指定变量的类型，然后是变量名。

​ 举例：double salary;
​ int age;
​ long renko;
​ boolean dool;

变量命名不能以数字开头，可以使用 " $ _ ",不能是java的关键字。

1.5.2、变量初始化

​ 声明一个变量之后，必须用赋值语句对变量进行初始化，未初始化就使用变量是 错误 的。

​ 例如：

int age;
System.out.println(age);

​ 想要对一个已经声明过的变量进行赋值，需要使用 " = " 把右边的值赋给左边的变量，如：

int age;
age = 18;

​ 也可以把变量的声明和初始化放在同一行。如：

int age = 18;

1.5.3、常量

​ 在java中，用关键字 final 声明常量。如：

final String NAME = "zhangsan";
final int AGE = 3;

​ 关键字 final 表示这个变量只能被赋值一次。一旦赋值之后，就不能够再更改了，命名规范上，常量名使用 全大写字母 命名。

​ 如果希望某个常量可以在一个类的多个方法中使用，通常将这些常量称为类常量。可以使用关键字 static final 设置一个类常量。如：

public class Hello{
    static final String NANE = "zhangsan";
    public static void main(String[] args){
        System.out.println(name);
    }
}

​ 注意：类常量需要定义在方法的外部，类的里面。定义之后类里面的方法都可以使用。

1.5.4、枚举类型

​ 自定义枚举类型。枚举类型包括有限个命名的值。如：

enum Size{SMALL,MEDIUM,LARGE,EXTRA_LARGE};
//声明这种类型的变量：
Size s = Size.MEDIUM;

​ Size 类型的变量只能存储这个类型声明中给定的某个枚举值，或者特殊值 null , null 表示这个变量没有设置任何值。

1.6、运算符

​ java 提供了一组丰富的算术和逻辑运算符以及数学函数。

1.6.1、算术运算符

​ 在 java 中，使用算术运算符 +（加）、-（减）、*（乘）、/（除）运算。如：

int s1 = 8;
int s2 = 4;
//加
int s3 = s1 + s2;
//减
int s3 = s1 -s2;
//乘
int s3 = s1 * s2;
//除
int s3 = s1 / s2;

​ 需要注意：整数被 0 除将会产生一个异常，而浮点数被 0 除将会得到无穷大或 NaN 结果。

1.6.2、数学函数与常量

​ 在 Math 类中，包含了各种各样的数学函数。在编写不同类别的程序时，可能需要的函数也不同。

​ 想要计算一个数值的平方根，可以使用 sqrt 方法：

double x = 4;
double y = Math.sqrt(x);
System.out.println(y);//输出

​ 在 java 中，没有幂运算符，因此需要借助于 Math 类的 pow 方法。如：

double y = Math.pow(x,a);

​ pow 方法有两个 double 类型的参数，其返回结果也为 double 类型。

​ flooMod 方法的目的是解决一个长期存在的有关整数余数的问题。考虑表达式 n % 2。如果 n 是偶数，这个表达式为 0 ；如果 n 是奇数，表达式则为 1。当然，除非 n 是负数。如果 n 为负，这个表达式则为 -1；

Math 类提供了一些常用的三角函数：

​ Math.sin
​ Math.cos
​ Math.tan
​ Math.atan
​ Math.atan2
​ 还有指数函数以及它的反函数——自然对数以及以 10 为底的对数：

​ Math.exp
​ Math.log
​ Math.log10

​ 最后，java还提供了两个用于表示 π 和 e 常量的最接近的近似值：

​ Math.PI
​ Math.E

1.6.3、数值类型之间的转换

​ 经常需要将一种数值类型转换为另一种数值类型。

​ 在上图中，有 6 个实线箭头，表示无信息丢失的转换；另外有 3 个虚线箭头，表示可能有精度损失的转换。

​ 当用一个二元运算符连接两个值时（例如 n + f，n 是整数，f是浮点数），先要将两个操作数转换为同一种类型，然后再进行计算。

• 如果两个操作数中有一个是 double 类型，另一个操作数就会转换为 double 类型。
• 否则，如果其中一个操作数是 float 类型，另一个操作数将会转换为 float。
• 否则，如果其中一个操作数是 long 类型，另一个操作数将会转换为 long 类型。
• 否则，两个操作数都将被转换为 int 类型

1.6.4、强制类型转换

​ 在必要的时候，int 类型的值将会自动地转换为 double 类型。但有时候也需要将 double 转换为int ，在 java 中，允许进行这种数值之间的类型转换，当然有可能会丢失一些信息。这种可能损失信息的转换要通过 强制类型转换来完成。强制类型转换的语法格式是在圆括号中给出想要转换的目标类型，后面紧跟待转换的变量名。如：

double s1 = 8.88;
int s2 = (int)s1;

​ s2的结果是 8 ；

​ 还可以调用 Math 类 round 方法，转换后的结果是四舍五入后的结果。如：

double s1 = 8.88;
int s2 = (int) Math.round(s1);

​ s2 的结果是 9 ；

1.6.5、结合赋值和运算符

​ 可以在赋值中使用二元运算符，这是一种很方便的简写形式。如

x += 4;

​ 等价于：

x = x + 4;

​ 也可以 +=、-=、/=、*=、%=……

1.6.7、自增与自减运算符

自增：变量本身加 1
自减：变量本身减 1

java 里面有两种形式：分别是：

• 运算符放在操作数后面的
• 运算符放在操作数前面

如：

int age = 18;
//第一种形式
age++;
age--;
//第二章形式
++age;
--age;

运算符在前面是先 加/减 1在计算

运算符在后面是先计算在 加/减 1

1.6.8、关系和 逻辑 运算符

关系运算符：

boolean（布尔）

值：false（错误）true（正确）

逻辑运算符

&& 与 &：两边都为 true 则为 true ，不然 false，&& 要是第一个表达式为 false 那么它就不可能是 true 就不会在看右边的了，& 两边都一定会看。

||：其中一边为 true 则为 true ，不然 false，要是第一个表达式为 true那么它就不可能是 false 就不会在看右边的了，| 两边都会看。

!：相反的，加上逻辑非会把最终结果反过来，false 变 true ，true 变 false。

^：如果两边不一样则结果为 true ，如果两边一样 则 结果为false。

如：

int s1 = 10;
int s2 = 11;
if(s1 == s2 && s1 > s2){//结果为false
    System.out.println("true");
}else{
    System.out.println("false");
}

1.6.9、三元运算符

语法：表达式 ？true ：false；

int s1 = 10;
int s2 = 11;
s1 > s2 ? "true":"false";

如果 左边表达式结果为 true 就返回 “true” 的内容

如果 左边的表达式结果为 false 就返回 “false” 的内容

1.6.10、位运算符

​ 位运算符是直接对数字底层 二进制进行操作的

& 按位与：两个为 1 则为 1 ，不然为 0

| 按位或：一个为 1 则为 1 ， 不然为 0

~ 取反：1 为 0 ，0 为 1

^ 异或：不一样则为 1 ，不然为 0

<< 左移运算符：二进制左移两位，右边补0

>> 右移运算符：二进制右移两位，正数左边第一位补0，负数补1

>>>无符号右移运算符：无符号右移运算符和右移运算符的主要区别在于负数的计算，无符号右移是高位补0，移多少位补多少个0

1.6.11、括号与运算符级别

• java的运算符都有自己的优先级,有（）会先执行（）里面的。

​ 例如：由于 && 的优先级比 || 的优先级比 || 的优先级高，所以表达式

a && b || c

等价于

(a && b) || c

运算符优先级：

1.7、字符串

​ java 没有内置的字符串类型，而是在标准 java 类库中提供了一个预定类，很自然地叫做 String。每个用双引号括起来地字符串都是 String 类的一个实例：

String name = "";//空字符串
String name = "zhangsan";

1.7.1、子串

​ String 类的 substring 方法可以从一个较大的字符串提取出一个子串（某一段字符）。如：

String greeting = "Hello";
String s = greeting.substring(0,3);

• 创建一个由字符"Hel"组成的字符串。
• 在 substring 中从 0 开始计算，直到 3 为止，但不包括3。

substring(开始位置，结束位置);

1.7.2、拼接

​ 与绝大多数程序设计语言一样，java 语言 允许使用 + 号拼接两个字符串。

int age = 18;
int name = "zhangsan";
System.out.println(name+age);	//输出：zhangsan18

1.7.3、不可变字符串

​ String 类没有提供修改字符串中某个字符的方法。如果希望将 greeting 的内容修改为"Help"，不能直接将 greeting 的最后两个位置的字符修改为 ’ p ’ 和 ’ ! '。
​ 在 java 中实现这项操作可以提取想要保留的子串，再与希望替换的字符拼接：

greeting = greeting(0.3) + "p!";

上面这条语句将 greeting 变量的当前值修改为 “Help!”。

1.7.4、检测字符串是否相等

可以使用 equals 方法检测两个字符串是否相等。如：

x.equals(y)

​ 如果字符串 x 与字符串 y 相等，则返回 true ；否则，返回 false。需要注意，x 与 y 可以是字符串变量，也可以是字符串字面量。如：

"Hello".equals(greeting)

想要检测两个字符串是否相等，而不区分大小写，可以使用 equalsIgnoreCase 方法。

"Hello".equalsIgnoreCase("hello")

equals 和 == 的区别

对于==：

作用于基本数据类型的变量，则直接比较其存储的 ”值“ 是否相等。

作用于引用类型的变量，则比较的是所指向的对象的地址。

对于 equals：

equals 方法不能作用于基本数据类型的变量。

如果没用对 Object 中 equals 方法进行重写，则比较的是引用类型的变量所指向的对象的地址，反之则比较的是内容

注意：String 这个类已经对 equals 方法进行了重写，比较的是字符串的内容。

1.7.5、空串与 Null 串

​ 空串 “” 是长度为0的字符串。可以用以下代码检查一个字符串是否为空：

if(str.length() == 0)

或

if(str.equals(""))

​ 空串是一个 java 对象，有自己的串长度（0）和内容（空）。不过，String 变量还可以存放一个特殊的值，名为 null，表示目前没有任何对象与该变量关联。

​ 检查一个字符串是否为 null，如：

if(str == null)

有时要检查一个字符串既不是 null 也不是空串，如：

if(str != null && str.length() != 0)

1.7.6、码点与代码单元

​ java 字符串由 char 值序列组成。char 数据类型是一个采用 UTF -16 编码表示 Unicode 码点的代码单元。

length 方法将返回采用 UTF-16 编码表示给定字符串所需要的代码单元数量。如：

String greeting = "Hello";
int n = greeting.length();	//返回 5

想要得到实际的长度，即码点数量，可以调用：

int cpCount = greeting.codePointCount(0,greeting.length());

调用 s.charAt(n) 将返回位置 n 的代码单元，n 介于 0 ~ s.length()-1之间。如：

char first = greeting.charAt(0);//返回 H
char last = greeting.charAt(4); //返回 o

要想得到第 i 个码点，如：

int index = greeting.offsetByCodePoints(0,1);//位置
int cp = greeting.codePointAt(index);	//转ASCII值

1.7.7、String API

​ java 中的 String 类包含了 50 多个方法。它们绝大多数都很有用，想了解 java 的类或方法就需要学会阅读 官方的 API 文档里面用对一些类或方法的详细讲解。

1.7.8、构建字符串

​ 有些时候，需要由较短的字符串构建字符串，如果采用字符串拼接的方式来达到这个目的，效率会比较低。每次拼接字符串时，都会构建一个新的String 对象，即耗时，又浪费空间。使用 StringBuilder 类就可以避免这个问题的发生。

首先，构建一个空的字符串构建器：

StringBuilder builder = new StringBuilder();

当每次需要添加一部分内容时，就调用 append 方法。

builder.append(ch); //加一个字符串
builder.append(str);//再加一个字符串，结果应该是 chstr

在字符串构建完成时就调用 toString 方法，将可以得到一个 String 对象，其中包含了构建器中的字符串序列。

String completedString = buider.toStrine();

输出之后就是你 buider 里面的内容。

StringBuilder 跟 StringBuffer 的 API 是一样的。

下面一些 StringBuilder 类中的重要方法。

java.lang.StringBuilder

• StringBuilder()

构造一个空字符串构建器。

• int length()

返回构建器或缓冲器中的代码单元数量。

• StringBuilder append(String str)

追加一个字符串并返回 this（当前对象）

• StringBuilder append(char c)

追加一个代码单元并返回 this（当前对象）

• StringBuilder appendCodePoint(int cp)

追加一个码点，并将其转换为一个或两个代码单元并返回 this（当前对象）

• void setCharAt(int i,char c)

将第 i 个代码单元设置为 c

• StringBuilder insert(int offset , String str)

在 offset 位置插入一个字符串并返回 this（当前对象）

• StringBuilder insert(int offset , char c)

在 offset 位置插入一个代码单元并返回 this（当前对象）

• StringBuilder delete(int starIndex , int endIndex)

删除偏移从 startIndex 到 endIndex - 1 的代码单元并返回 this（当前对象）

• String toString();

返回一个与构建器或缓冲器内容相同的字符串

本总结是基于《java核心技术卷一》写的，也可当作阅读笔记，日后更后面的。
写文章的目的主要是提升自己，发CSDN的目的主要是一起学习

如有问题请及时指出