Java语法

Java C#

在学习安卓打包的时候再一次运用到了java，说来也有一年左右没有怎么用了，正好借着此次机会完整的复习一遍，之前学习C#的时候经常用java的角度去看待C#，而这次全文会着重于从C#再次去看待java。

环境和编译器设置

导入

鉴于myeclipse实在有点年头了，本次开发环境基于IDEA。

知识点1：设置中文

IDEA和Rider对中文的支持都非常不错，建议按照插件使用。

File——Setting——Plugins

搜索Chinese安装重启

知识点2：字体和大小

File——Setting——Editor——Font

字体设置为：Consolas

字体大小：随意

知识点3：注释

三种注释方式

//单行注释

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

/**文档注释
 * 一般用来注释函数和类
 * 类似C#中的 /// 注释
 */

知识点4：注释颜色修改

File——Setting——Editor——Color Scheme——Language Defaults——Comments

知识点5：折叠代码

java没有C#的代码折叠，所以只能使用IDEA的自动折叠

或者进行手动：

选中代码——右键——折叠——折叠选择/删除区域

知识点6：文件编码

File——Setting——Editor——文件编码

有三个可设置的地方，我们通常统一设置成UTF-8

Java变量相关

知识点1：Java中的有符号整型

1.byte(1个字节，8位，-2^7 ~ 2^7 - 1，-128 ~ 127)

System.out.println("byte位数" + Byte.SIZE);
System.out.println("byte最大值" + Byte.MAX_VALUE);
System.out.println("byte最小值" + Byte.MIN_VALUE);

2.short(2个字节，16位，-2^15 ~ 2^15 - 1，-32768 ~ 32767)

System.out.println("short位数" + Short.SIZE);
System.out.println("short最大值" + Short.MAX_VALUE);
System.out.println("short最小值" + Short.MIN_VALUE);

3.int(4个字节，32位，-2^31 ~ 2^31 - 1，-2,147,483,648 ~ 2,147,483,647)

System.out.println("int位数" + Integer.SIZE);
System.out.println("int最大值" + Integer.MAX_VALUE);
System.out.println("int最小值" + Integer.MIN_VALUE);

4.long(8个字节，64位

，-2^63 ~ 2^63 - 1，9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807)

System.out.println("long位数" + Long.SIZE);
System.out.println("long最大值" + Long.MAX_VALUE);
System.out.println("long最小值" + Long.MIN_VALUE);

注意：Java最初设计中没有无符号类型

Java 8中添加了一些和无符号类型有关的一些方法(但是一般使用较少)

知识点2：Java中的浮点型

Java的浮点数标识和C#一样，float要加f，否则默认double

1.float(4个字节，32位)

System.out.println("float位数" + Float.SIZE);
System.out.println("float最大值" + Float.MAX_VALUE);
System.out.println("float最小值" + Float.MIN_VALUE);
float f = .5f;
System.out.println(f);
f = 1.f;
System.out.println(f);

2.double(8个字节，64位)

System.out.println("double位数" + Double.SIZE);
System.out.println("double最大值" + Double.MAX_VALUE);
System.out.println("double最小值" + Double.MIN_VALUE);
double d = 1.5;

知识点3：Java中的其它类型

1.boolean(单个boolean在编译时使用int类型，这时4个字节；boolean数组时，编译时用字节数组，所以占1个字节)

即C#的bool

默认值是false

boolean b0 = true;
boolean[] bs;

2.char(2个字节，16位)

System.out.println("char位数" + Character.SIZE);
char c = 'A';
System.out.println(c);

3.String(根据字符串长度而定)

String str = "123";
System.out.println(str);

知识点4：Java中的常量

关键字：final

特点：必须初始化，不能被修改

但是和C#的const不同，它更类似C#的readonly，因为final并不会默认是静态的。

知识点5：类型转换

1.隐式转换：低级（字节少的）到高级（字节多的）

记住一句话大容器可以装小容器不需要我们去处理

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

byte b2 = 111;
short s2 = b2;

2.显示转换：括号强转，高级到低级会丢失精度或者报错

int i3 = 40000;
s2 = (short) i3;
System.out.println(s2);
float f2 = 2.5f;
i3 = (int)f2;
System.out.println(i3);的parse相关方法

总结

Java的变量类型和C#非常的类似

其中需要注意的是

Java中没有专门的无符号类型
Java中的常量关键字和C#不一样
一些关键字和方法写法不同

其它的变量相关操作表现和C#中极奇相似

Java运算符

知识点1：赋值运算符

符号：=

int i = 10;
int i2,j2,k2;
i2 = j2 = k2 = 10;

知识点2：算数运算符

加： +

减： -

乘： *

除：/

余： %

注意：0不能作为除数

i = i + 10;
System.out.println(i);
i += 10;
System.out.println(i);

知识点3：自增减运算符

自增：++

自减：--

System.out.println(i++);//30 先用再加
System.out.println(++i);//32 先加再用

知识点4：比较运算符

>、<、==、>=、<=、!=

boolean b = 3 < 2;
System.out.println(b);

知识点5：逻辑运算符

逻辑与：&&

逻辑或：||

逻辑非：!

b = true || false;
System.out.println(!b);

知识点6：位运算符

位与：& (同为1则1，有0则0)

位或：| (有1则1)

异或：^ (相同为0，不同为1)

取反：~ (1变0, 0变1)

左移：<<

右移：>> (最高位保留正负)

无符号右移：>>> (最高位始终补0)

知识点7：三目运算符

条件表达式？值1 : 值2

String i3 = false ? "3" : "2";
System.out.println(i3);

知识点8：运算符优先级

优先级运算符运算符

1 括号 ()

2 正负号 +, -

3 自增减、逻辑非 ++、--、!

4 乘除取余 *、/、%

5 加减 +,-

6 移位运算 <<、>>、>>>

7 比较大小 >、<、>=、<=

8 比较是否相等 ==、!=

9 位与 &

10 异或 ^

11 位或 |

12 逻辑与 &&

13 逻辑或 ||

14 三目运算符 ? :

15 赋值运算符 =

当顺序不确定的时候建议或用括号即可。

总结

Java中运算符基本和C#一模一样

就把它当做C#来写即可

Java 条件分支语句

知识点1：条件分支——if语句

if语句后如果只有一行代码可以省略大括号

int i = 1;
if( i == 5 )
{
    System.out.println("等于5");
}
else if( i < 5)
{
    System.out.println("小于5");
}
else
{
    System.out.println("大于5");
}

知识点2：条件分支——switch语句

switch语句中内容只能是：整型、字符型、字符串、枚举

Java的switch语句贯穿中可以插入代码逻辑，这点和C#不同，C#只能多个case共享逻辑

注意：当i=2时，只会执行case2和case3，case1会被跳过。

switch (i)
{
    case 1:
        System.out.println(i);
    case 2:
        System.out.println(i + 2);
    case 3:
        System.out.println(i + 1);
        break;
    default:
        break;
}

总结

Java中的条件分支语句用法和C#中基本一致

就当成写C#即可

但是switch语句的贯穿方面有一定的区别

Java循环语句

知识点1：while循环

int i = 0;
while (i <= 5)
{
    System.out.println(i);
    ++i;
}

知识点2：do while循环

do {
    System.out.println(i);
    ++i;
}while (i <= 10);

知识点3：for循环

for (int i2 = 0; i2 < 10; ++i2)
{
    System.out.println(i2);
}

知识点4：foreach语句

注意：Java中不使用foreach

foreach语句其实是for循环的特殊简化版本

主要用于遍历复合容器中的元素

写法：

for( 元素类型 x : 遍历对象 ) {}

int[] arr = new int[]{1,2,3,4,5};
for (int a : arr ) {
    if(a == 1)
        continue;
    System.out.println(a);
}
System.out.println("循环后的逻辑");

知识点5：break和continue

break 是跳出循环

continue 是跳过本次循环继续执行下一次循环

总结

Java中的循环语句和C#中基本相同

就像写C#一样书写即可

只需要注意for的特殊写法（foreach语句）

Java 数组

知识点1：一维数组

声明

注意： Java中的数组申明比C#中多一种方式

   //1.数组元素类型 数组名[]
int arr[];
   //2.数组元素类型[] 数组名
int[] arr2;

初始化

  //1.new 数组类型[容量]
arr = new int[5];
int arr3[] = new int[3];
   //2.new 数组类型[]{内容};
arr = new int[]{1,2,3,4,5};
   //3.{内容}
int[] arr4 = {1,2,3,4};

遍历

    //for循环
for (int i = 0; i < arr.length; ++i)
{
    System.out.println(arr[i]);
}
    //foreach语句
for (int n : arr) {
    System.out.println(n);
}

知识点2：二维数组

注意：Java中的二维数组写法更类似C#确定了第二位的交错数组，C#本身的二维数组和交错数组格式差别是比较大的。

声明：

  //1.数组元素类型 数组名[][]
int arrs[][];
   //2.数组元素类型[][] 数组名
int[][] arrs2;

初始化

   //1. new 数组类型[行][列]
arrs = new int[3][2];
    //2. new 数组类型[][]{{内容},{内容}};
arrs = new int[][]{{2,1},
                   {1,2},
                   {3,2}};
    //3. 数组元素类型[][] 数组名 = {{内容},{内容}}
int arrs3[][] = {{2,1},
        {1,2},
        {3,2}};

遍历

for循环和foreach语句

  //1.for循环
for (int i = 0; i < arrs3.length; ++i)
{
    for (int j = 0; j < arrs3[i].length; ++j )
        System.out.println(arrs[i][j]);
}
    //2.foreach语句
for (int[] arr8 : arrs3) {
    for (int n2: arr8) {
        System.out.println(n2);
    }
}

知识点3：交错数组

注意：Java中交错数组使用和C#基本类似

初始化和声明

int arr10[][] = new int[3][];
arr10[0] = new int[]{1,2,3};
arr10[1] = new int[]{1,2};
arr10[2] = new int[]{1};

遍历

   //1.for循环
for (int i = 0; i < arr10.length; ++i)
{
    for (int j = 0; j < arr10[i].length; ++j )
        System.out.println(arr10[i][j]);
}
   //2.foreach语句
for (int[] arrss : arr10) {
    for (int n: arrss) {
        System.out.println(n);
    }
}

总结

Java中的数组使用和C#中基本类似

区别是

数组的声明有些许区别
Java中的二维数组和交错数组的写法都是[][]，而C#中的二维数组是[,] 交错数组是[][]

Java 中Arrays类的静态方法

知识点1：Arrays类是什么

Arrays类是Java提供的一个专门对数组进行操作的类

它提供了很多静态方法，共我们对数组进行处理

比如排序、查找、填充等等方法

使用它需要导入java.util.Arrays包（类似C#中的命名空间）

知识点2：填充替换数组元素

Arrays.fill 方法可以帮助我们对数组进行填充

它有两个重载

1.Arrays.fill(数组,填充值)

int arr[] = new int[5];
for (int n : arr) {
    System.out.println(n);
}
Arrays.fill(arr, 5);
System.out.println("***************");
for (int n : arr) {
    System.out.println(n);
}

2.Arrays.fill(数组,填充起始位置(包括),填充结束位置(不包括),填充值)

Arrays.fill(arr, 1, 4, 1);
System.out.println("***************");
for (int n : arr) {
    System.out.println(n);
}

Arrays.fill(arr, 1, arr.length, 0);
System.out.println("***************");
for (int n : arr) {
    System.out.println(n);
}

知识点3：数组排序

Arrays.sort(数组) 方法可以对数组进行默认的升序排序

arr = new int[]{4,3,6,1,2,8,1};
Arrays.sort(arr);
System.out.println("***************");
for (int n : arr) {
    System.out.println(n);
}

知识点4：复制数组

1.Arrays.copyOf(数组，复制长度) 方法可以赋值指定数组的指定长度

若长度小于传入数组，则截取；若长度大于传入数组，则用默认值填充

int[] arr2 = Arrays.copyOf(arr, 10);
System.out.println("***************");
for (int n : arr2) {
    System.out.println(n);
}

2.Arrays.copyOfRange(数组，开始复制索引（包括），赋值的最后索引位置（不包括）)

arr2 = Arrays.copyOfRange(arr, 1, 4);
System.out.println("***************");
for (int n : arr2) {
    System.out.println(n);
}

知识点5：查询数组

Arrays.binarySearch(数组，搜索元素)

注意：由于binarySearch内部是对数组进行二分查找

所以使用前必须对数组进行排序

Arrays.sort(arr);

一定该记住使用该API之前一定要排序

如果数组当中没有想要寻找的元素那么返回值为负数

//先排序
Arrays.sort(arr);
//全体查找
int index = Arrays.binarySearch(arr, 1);
//按范围查找
Arrays.binarySearch(数组，开始索引(包括)，结束索引(不包括)，搜索元素)

总结

Java中如果相对数组进行填充、替换、排序、复制、查询等操作

我们可以使用Arrays类中的静态方法

填充替换：fill

排序：sort

复制：copyOf、copyOfRange

查询：binarySearch

Java函数

知识点1：Java中的函数和C#对比

Java中函数和C#中函数的使用基本一致

函数的声明、重载、使用等就按照C#中的基础规则使用即可

主要区别如下：

Java中没有ref和out关键字
Java中可变参数写法有些许不同
Java中函数参数没有默认参数用法

知识点2：复习函数基本概念

函数（方法）

本质是一块具有名称的代码块

可以使用函数（方法）的名称来执行该代码块

函数（方法）是封装代码进行重复使用的一种机制

函数（方法）的主要作用

封装代码
提升代码复用率（少写点代码）
抽象行为

知识点3：Java的函数写在哪里

class语句块中

Java中没有结构体，所以不存在结构体语句块

知识点4：Java基本语法

修饰符返回类型函数名(参数类型参数名1, 参数类型参数名2, .......)

{

函数的代码逻辑;

.............

return 返回值;(如果有返回类型才返回)

}

修饰符

和C#一样，有static public private protected 等

返回类型

关于返回类型 void(表示没有返回值)
返回类型可以写任意的变量类型

函数名

关于函数名 Java中一般使用驼峰命名法 myName（驼峰命名法） MyName(帕斯卡命名法)

参数

参数不是必须的，可以有0~n个参数参数的类型也是可以是任意类型的，多个参数的时候需要用逗号隔开
参数名驼峰命名法

return

当返回值类型不为void时必须通过return返回对应类型的内容（注意：即使是void也可以选择性使用return来中止函数）

知识点5：实际运用

//1.无参无返回值函数
public static void sayHellow()
    {
        System.out.println("你好世界");
    }

sayHellow();
//2.有参无返回值函数
   public static  void saySomthing(String str)
    {
        System.out.println(str);
    }

saySomthing("哈哈哈啊哈");
//3.无参有返回值函数
  public static String whatYourName()
    {
        return "唐老狮";
    }

System.out.println(whatYourName());
//4.有参有返回值函数
    public static int sum(int a, int b)
    {
        return a + b;
    }

System.out.println(sum(1,2));

//5.有参有多返回值函数
  public static int[] test(int a, int b)
    {
        return new int[]{a,b,3,4};
    }

int[] arr = test(1,2);
for (int n : arr) {
    System.out.println(n);
}
//6.可变参数
   public static void test(String... strs)
    {
        for (String s : strs) {
            System.out.println(s);
        }
    }

test("123123","dsaafasdf","123123123");

总结

Java中函数的使用和C#基本一致

区别主要是

Java中没有ref和out关键字
Java中可变参数写法有些许不同用...表示可变参数
Java中函数参数没有默认参数的用法
Java中函数的命名方式用的是驼峰命名法

Java 面向对象—封装

知识点1：面向对象回顾

概念：

万物皆对象

用程序来抽象（形容）对象

用面向对象的思想来编程

面向对象三大特性

封装、继承、多态

注意：

面向对象是一种编程范式

面向对象编程语言的编程思想和使用几乎是一致的

使用C#中的面向对象编程思想去写Java即可

Java中也是通过class类去封装对象的

知识点2：Java中类的封装

Java中的类声明和使用和C#中基本一模一样

声明

class 类名

{

//特征——成员变量

//行为——成员方法

//构造函数

//finalize函数

//静态函数

}

注意：Java中没有C#中的

成员属性（需要手动写函数来实现，名字一般为get set+变量名，但是IDEA支持右键变量自动生成get、set方法）
析构函数（有类似的finalize函数）
索引器
运算符重载

演示类

public class Person {
    //静态成员
    //静态变量
    public static int testStaticI;

    public static void test()
    {

    }


    //成员变量
    public String name = "唐老狮";

    public String getSecret() {
        return secret;
    }

    private String secret = "秘密";
    protected  int age = 18;

    public Person girlFriend;
    public Person[] boyFrient;

    public E_Sex sex = E_Sex.Man;

    //成员方法
    public void Speak(String str)
    {
        System.out.println(str);
    }

    //构造函数
    public Person()
    {

    }
    //如果声明了有参构造函数 那么默认的无参构造函数就没有了
    //如果想要保留 需要自己实现
    public Person(String name)
    {
        this.name = name;
    }

    //当对象变成垃圾 然后垃圾回收时会调用该函数
    //下一次垃圾回收时 才会回收该对象
    protected void finalize()
    {
        System.out.println("回收");
    }

    public enum E_Sex
    {
        Man,
        Woman,
    }
}

注意——关于静态类

值得一提的是，Java不允许单独的静态类（顶级静态类）存在，而只允许内部类设置为静态。

但是静态方法本身就可以直接调用，C#的静态类本质上可以被看作是一种特殊的声明，其目的是明确指出这个类是专门用于包含静态成员的，而不是用于创建实例。

所以这个差别是不会影响到我们的大部分场合下的静态使用的。

总结

Java中类的封装规则和C#基本一致

相对C#来说还少了不少功能，使用起来更加简单

Java 面向对象—继承

知识点1：Java中继承和C#中的相同点

类与类之间只能单继承
万物之父都是Object
遵循里氏替换原则(可以父类装子类对象)

知识点2：Java中继承的写法

关键字：extends

知识点3：万物之父Object中的关键方法

1.getClass():类似C#中的getType()

Father f = new Father();
System.out.println(f.getClass());

2.toString():将对象以字符串形式返回

3.equals():比较两个对象的内部内容，而==是判断引用地址是否相等

知识点4: 父子类的上下转换（里氏替换原则）

//1.子类自动向上转换
Father f2 = new Son();
//2.父类强制向下转换
Son s = (Son)f2;

知识点5：instanceof关键字

用于判断对象类型，类似C#中的is关键字

if(f2 instanceof Father)
{
    System.out.println("是Father类");
}

if(f2 instanceof Son)
{
    Son s2 = (Son)f2;
    System.out.println("是Son类");
}

知识点6：final关键字

类似C#中的密封关键字

让变量无法被修改（常量）

让函数无法被重写

让类无法被继承

总结

Java中继承使用和C#基本一致

只是有一些关键字和小规则不同而已

Java 面向对象—多态

知识点1: Java中的vob

Java中没有vo关键字，也就是virtual(虚函数)和override(重写)

我们如果要重写基类的方法，直接在子类中实现同名方法即可

它会直接覆盖父类方法！！

Java中有类似 base 的关键字 super

注意：重写是Java会自动补全一个@Override

它类似于注释，可有可无，主要是用来帮助我们阅读代码

知识点2：抽象类和抽象方法

Java中的抽象类和抽象方法使用和C#中基本一致

关键字：abstract

抽象类不能被实例化

抽象方法在抽象类中声明，必须被实现

知识点3：接口

Java中接口中方法默认(只能)为public
Java中接口可以声明字段，但是默认(只能)是static和final的，也就是静态常量
Java中继承接口的关键字是implements，一般写在继承类之后
继承多个接口用逗号分隔
Java中不存在显示实现接口，重写不同接口的同名方式时，只能两个接口共享一个方法

总结

Java中多态相关知识点

和C#中基本一致，相对C#更简单

没有vo关键字，有类似b的super
继承接口用implements
接口中可以声明变量，但是是静态常量
不存在显示实现接口（多个接口存在同名方法，实现一次即可）

Java包

知识点1：Java中的包是什么？

Java中的包（package）类似C#中的命名空间

主要用于解决类名冲突

同名类做不同逻辑时

可以将两个类放到两个不同的包中

而且不同于C#，Java的包不能类似C#直接代码创建命名空间，而是必须手动右键创建（类似文件夹），并把所属的类放入其中。

知识点2：包名规则

多人完成，版权属于发起者

indi.发起这名.项目名.模块名....

独立完成，公开，版权属于个人

pers.个人名.项目名.模块名

独立完成，非公开，版权属于个人

priv.个人名.项目名.模块名

团队研发，版权属于团队

team.团队名.项目名.模块名

公司研发，版权属于公司

com.公司名.项目名.模块名

注意：Java中规定包名统一用小写，用.分割

知识点3：创建包

在左侧src右键——>新建——>软件包

知识点4：使用包

想要使用不同包中的内容

需要在脚本前引用包

关键词：import（类似C#中的using）

知识点5：静态导入包

import static 包中的静态成员

在使用时就不用写类名直接调用静态成员即可

类似C#中的静态导入

总结

Java中的包概念和使用类似C#中的命名空间

但是相对C#中的命名空间来说

Java中需要自己先创建包

Java内部类

知识点1：Java中的内部类

注意：Java中的内部类的使用和C#中不同，C#中创建嵌套类（内部类）的实例不需要通过外部类的实例，可以直接实例化。

1.Java中的内部类在外部使用时必须伴随包裹它的外部类的出现而出现

声明语法为

外部类 outer = new 外部类();
  外部类.内部类 inner = outer.new 内部类();
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.Test();

但是java的内部类和C#的内部类一样，可以调用外部类的内容

2.外部类中的所有内容（包括私有）都可以直接在内部类中使用

3.内部类和外部类中的同名成员，通过this 和外部类.this来区分

知识点2：匿名内部类

匿名内部类，在声明一个类对象时临时拓展该对象

但是拓展的内容一般是基于外部类的

注意：

不能写构造方法
不能定义静态成员
一般基于外部类已有方法实现内容
如果匿名类创建的对象不记录，用完一次后会马上被销毁

Outer outer2 = new Outer(){
    @Override
    public void Eat() {
        System.out.println("吃东西");
    }

    @Override
    public void Speak() {
        System.out.println("说话");
    }
};
outer2.Eat();
outer2.Speak();

总结

1.Java中的内部类在外部使用时必须伴随包裹它的外部类的出现而出现

2.外部类中的所有内容（包括私有）都可以直接在内部类中使用

3.内部类和外部类中的同名成员，通过this 和外部类.this来区分

匿名类使用较少，主要做了解，能看懂即可

Java String

知识点1：字符串声明

值得一提的是，C#也和Java下面的情况相同

1.直接赋值字符串，注意：如果字符串相同，那么他们指向同一实体，在公共内存区域

String s1 = "A唐老狮A";
String s2 = "A唐老狮A";

2.new String，注意：使用new，即使字符串相同也是不同实体

String s3 = new String("唐老狮");
String s4 = new String("唐老狮");
char[] chars = {'a','b','c'};
String s5 = new String(chars);
System.out.println(s5);

知识点2：字符串拼接

Java中字符串拼接规则和C#中相同，通过+好即可拼接

拼接时并不是修改原String，而会生成新的String，和C#中规则相同

s1 = s1 + "123" + 1 + 1.2f;

System.out.println(s1);

知识点3：String中常用方法

1.判断字符串是否相等

Java中没有运算符重载，所以==是用于判断引用地址

if(s1 == s2)
{
    System.out.println("s1引用和s2引用地址指向一个空间");
}
if(s3 == s4)
{
    System.out.println("s3引用和s4引用地址指向一个空间");
}
else
{
    System.out.println("s3引用和s4引用地址不同");
}
//  String之间进行判断，使用equals方法，还有一个不区分大小写的equalsIgnoreCase方法
if(s3.equals(s4))
{
    System.out.println("s3和s4的字符串相等");
}
String s6 = new String("ABC");
String s7 = new String("abc");
if(s6.equalsIgnoreCase(s7))
{
    System.out.println("忽略大小写的判断字符串是否相等");
}

2.长度 int length()

System.out.println(s1.length());

3.正向查找 int indexOf(String s)

System.out.println(s1.indexOf("A"));

4.反向查找 int lastIndexOf(String s)

System.out.println(s1.lastIndexOf("A"));

5.获取指定索引处字符 char charAt(int i)

System.out.println(s1.charAt(1));

6.获取子字符串 String substring(int beginIndex),string substring(int beginIndex, int endIndex)

System.out.println(s1.substring(2));
System.out.println(s1.substring(2, 4));

7.去除首尾空格 String trim()

String s33 = "   1231 23123   ";
System.out.println(s33);
System.out.println(s33.trim());

8.字符串替换 String replace(target, replacement)

System.out.println(s33.replace('1', 'A'));

9.判断字符串开始和结尾 boolean startsWith(String str), boolean endsWith(String str)

String s34 = "222333.txt";
System.out.println(s34.startsWith("223"));
System.out.println(s34.endsWith(".txt"));

10.大小写转换大转小 String toLowerCase(), 小转大 String toUpperCase()

String s35 = "AAAABBB";
System.out.println(s35.toLowerCase());
String s36 = "aaAAbbBB";
System.out.println(s35.toUpperCase());

11.字符串分割 String[] split(String sign)

String s37 = "123,345,678,123";
String[] strs = s37.split(",");
for (String str: strs) {
    System.out.println(str);
}

12.字符串格式化 String format(String, Object...)

%b、%B：boolean类型格式化符号

%s、%S：String类型格式化符号

%c、%C：char类型格式化符号

%d：十进制数格式化符号

%o：八进制数格式化符号

%x、%X：十六进制数格式化符号

%e：十进制数的科学计数法格式化符号

%tF:年-月-日时间格式

%tD:月/日/年时间格式

%tc:全部日期和时间信息

%tr:时:分:秒 PM(AM) 时间格式

%tT:时:分:秒 24小时制时间格式

%tR:时:分 24小时制时间格式

boolean b = true;
Date date = new Date();
String s = String.format("%tT", date);
System.out.println(s);

总结

Java中String在使用上和C#类似

但是需要注意以下两点区别

直接赋值字符串，如果字符串相同，则指向同一引用;new String，即使字符串相同引用也不同
中字符串比较使用equals，用==号是比较的引用地址

Java StringBuilder

知识点1：StringBuilder是什么？

Java中的StringBuilder和C#基本一致

主要是用于处理会频繁修改的字符串的

如果你的字符串变量会频繁被修改

建议使用StringBuilder可以帮助我们节约性能

知识点2：StringBuilder节约性能的体现

String str = new String("");
long startTime = System.currentTimeMillis();
for(int i = 0; i < 10000; ++i)
    str += i;
long endTime = System.currentTimeMillis();
System.out.println("String拼接消耗的时间：" + (endTime - startTime));

StringBuilder strBuilder = new StringBuilder("");
startTime = System.currentTimeMillis();
for(int i = 0; i < 10000; ++i)
    strBuilder.append(i);
endTime = System.currentTimeMillis();
System.out.println("StringBuilder拼接消耗的时间：" + (endTime - startTime));

从这个例子可以对比出，在频繁修改字符串时，使用StringBuilder效率会高很多

知识点3：StringBuilder中的常用方法

1.初始化构造函数

StringBuilder strB = new StringBuilder("");

2.拼接字符串append(内容)

strB.append(1);
strB.append("123123123");

5.转为String打印 toString()

String str2 = strB.toString();
System.out.println(strB);

3.插入字符串insert(位置，内容)

strB.insert(1,"唐老狮");
System.out.println(strB);

4.删除指定字符delete(开始位置，结束位置)

删除的内容为开始位置~结束位置-1

strB.delete(1,4);
System.out.println(strB);

总结

Java中的StringBuilder的使用和作用和C#中基本一致

如果项目中的字符串会频繁修改，建议使用StringBuilder

课时 42 : Java 泛型

知识点1：Java中泛型

Java中泛型使用的基本规则和C#中一致

泛型可以代表一切类型，主要使用上就是泛型类和泛型方法

主要区别如下

泛型方法写法用法不同
泛型约束不同
泛型类型通配符
一些基础类型必须写他们的包装类名，不能写变量类型

参考泛型类

public class TestT<T> {
    public T testValue;

    public T TestFun(T t)
    {
        return null;
    }

    //Java中的泛型方法 是写到访问修饰符后面的
    public<K> void TestFun2(K k)
    {

    }
}

下面的知识点代码会以此类为例。

知识点2：泛型基本用法

泛型类

C#的泛型实例化要求你在使用构造函数时明确指定泛型类型参数

而java有一种“菱形”语法，允许在实例化泛型类时不必重复在构造器后面指定泛型的类型参数，前提是这个类型参数可以从变量的类型或者其他方式中推断出来。

TestT<Float> obj = new TestT<>();
obj.testValue = 11f;
obj.TestFun(15f);

其他和C#基本相同。

泛型方法

Java也和C#一样拥有强大的自动泛型类型判定能力，当调用泛型方法的参数涉及到泛型类型的时候（实际上语法允许，不过参数没有用到泛型的场合可能比较少见），可以指明类型调用，也可以直接通过传入参数让泛型自己判定

这种情况下泛型方法的调用可能类似一个没有泛型的普通方法。

obj.TestFun2("123");

知识点3：Java中的泛型限制（泛型约束）

T extends 类名或接口名：表示泛型类型必须是或者继承某一个类或接口

TestT<Son> obj = new TestT<>();

知识点4：泛型中的类型通配符 "?"

泛型类名称<? extends 类名> 变量名 = null;

? extends 类名表示类未知，需要使用该泛型对象时，可以单独实例化

TestT<?> obj2 = null;
obj2 = new TestT<Son>();
obj2 = new TestT<Father>();

总结

Java中泛型和C#中使用规则上基本相同

主要区别是

泛型方法写法和使用不同
泛型约束不同
泛型类型通配符 ?
一些基础类型必须写他们的包装类名，不能写变量类型

Java ArrayList 和 LinkedList

知识点1：Java中各集合类之间的关系

Java中的集合类就类似C#中的List和Dictionary的存在

主要用于批量存储对象，并且可以动态添加，动态删除

继承图

知识点2：Collection接口中的方法

add(E e) 添加元素
remove(Object o) 移除元素
clear() 清空元素
isEmpty() 是否为空
iterator() 获取迭代器，可以用于遍历
size() 集合中元素个数
contains() 判断元素是否存在
toArray() 将容器中元素转为数组

知识点3：List接口中的方法

get(int index) 获取指定位置元素
set(int index, Object obj) 修改集合中指定位置的元素

知识点4：ArrayList和LinkedList类

两者方法上的使用完全一致，因为他们继承相同的接口

区别：

ArrayList本质是数组，是顺序存储

LinkedList本质是链表，是链式存储

LinkedList在插入删除时效率高于ArrayList

ArrayList在访问集合中指定位置对象时效率高于LinkedList

常用方法：

初始化

非常类似C#中的List

ArrayList<String> list = new ArrayList<>();
ArrayList<Integer> list2 = new ArrayList<>();
LinkedList<String> linkedList = new LinkedList<>();

增

list.add("1");
list.add("2");
list.add("3");
list2.add(1);
list2.add(2);
list2.add(3);

删

list.remove("3");
if(list.isEmpty())
    System.out.println("list容器为空1");
list.clear();
if(list.isEmpty())
    System.out.println("list容器为空2");
//list.remove(2);
//如果我们的容器当中存储的是int类型 在移除的时候 我们只能通过索引移除
list2.remove(1);

查

Java没有C#索引器的概念，无法用[]直接查，得用提供的方法。

System.out.println(list2.get(0));
System.out.println(list2.get(1));

if(list2.contains(2))
    System.out.println("存在2元素");

改

list2.set(0, 99);

遍历

//三种方式
//for循环
for(int i = 0; i < list2.size(); ++i)
    System.out.println(list2.get(i));
//foreach语句
for (Integer i : list2)
    System.out.println(i);
//迭代器
Iterator<Integer> it = list2.iterator();
while (it.hasNext())
    System.out.println(it.next());

转数组

//Object[] objs = list2.toArray();
Integer[] ints = new Integer[2];
list2.toArray(ints);

总结

Java中的ArrayList和LinkedList类似

C#中的List和LinkedList

根据自己的实际情况选择使用即可

Java HashSet 和 TreeSet

知识点1：回顾Java中集合类关系

继承图

Collection接口中的方法

add(E e) 添加元素
remove(Object o) 移除元素
clear() 清空元素
isEmpty() 是否为空
iterator() 获取迭代器，可以用于遍历
size() 集合中元素个数
contains() 判断元素是否存在
toArray() 将容器中元素转为数组

知识点2：HashSet和TreeSet的区别

相同点：他们都不允许存储重复的元素，如果传入重复的只会记录一个

他们相对上节课的ArrayList和LinkedList最大的使用区别就是他们可以去重

都不能像ArrayList和LinkedList通过索引获取或修改元素

不同点：他们的底层数据结构不同，HashSet底层结构是哈希表，TreeSet底层结构是树

TreeSet是有序排列的（会自动将加入元素进行排序），HashSet不一定有序

TreeSet相对HashSet由于多继承了接口，所以有更多的方法可以使用

注意：TreeSet具有排序功能

元素是数字时，按照大小升序排列

元素是字符串时，按照字符的编码值升序排列

元素是自定义类时，可以继承Comparable接口重载其中的方法

特别是compareTo方法，它用于制定排序规则

知识点3：HashSet和TreeSet的常用方法

初始化

HashSet<Integer> hashSet = new HashSet<>();
TreeSet<Integer> treeSet = new TreeSet<>();

增

treeSet.add(3);
treeSet.add(2);
treeSet.add(1);
treeSet.add(1);
treeSet.add(1);
treeSet.add(1);
treeSet.add(0);

删

//这两个容器都没有通过索引取移除的重载
treeSet.remove(0);

查

if(treeSet.contains(0))
    System.out.println("存在0元素");

改（不支持）

Set不支持进行改的操作，因为Set没有重复的元素

遍历

//  只有两种遍历 foreach语句和迭代器，无法通过for循环
for (Integer i : treeSet)
    System.out.println(i);

Iterator<Integer> it = treeSet.iterator();
while (it.hasNext())
    System.out.println(it.next());

知识点4：TreeSet独有的方法

1.first() 返回当前第一个元素

System.out.println(treeSet.first());

2.pollFirst() 取出当前第一个元素

和返回不同，取出后会删除元素。

System.out.println(treeSet.pollFirst());
System.out.println("*********************");
for (Integer i : treeSet)
    System.out.println(i);

3.last() 返回最后一个元素

System.out.println(treeSet.last());

4.pollLast() 取出当前最后一个元素

System.out.println(treeSet.pollLast());
System.out.println("*********************");
for (Integer i : treeSet)
    System.out.println(i);

treeSet.add(1);
treeSet.add(3);
treeSet.add(4);

5.headSet(E obj) 返回一个新Set集合，新集合是传入对象之前的所有对象

SortedSet<Integer> newSet = treeSet.headSet(3);
for (Integer i : newSet)
    System.out.println(i);

6.subSet(E b, E e) 返回一个新Set集合，新集合是传入对象b 和 e之间的所有对象，左包含，右不包含

7.tailSet(E obj) 返回一个新Set集合，新集合是传入对象（包含）之后的所有对象

总结

Set相关集合的特点是

不会存储重复元素，如果我们有去重需求可以选择他们
只能遍历获取所有元素，不能单独获取中间的某个元素
TreeSet会自动排序，有多出的方法，如可以取出（弹出）首尾

Java HashMap 和 TreeMap

知识点1：回顾Java中集合类关系

Map集合类似C#中的Dictionary字典

以键值对形式存储数据

继承图

知识点2：Map接口中的方法

put(K key, V value) 添加键值对
containsKey(Object key) 判断是否存在键
containsValue(Object value) 判断是否存在值
get(Object key) 如果存在key，则返回对应值，否则返回null
keySet() 返回该集合中的所有key对象形成的Set集合
values() 返回该集合中所有value对象形成的Collection集合
size() 键值对对数
isEmpty() 是否为空
remove(Object key) 根据键移除
clear() 清空容器

知识点3：HashMap和TreeMap之间的区别

相同点：他们都是以键值对形式存储数据，方法使用基本相同

不同点：

1.HashMap允许有null键和null值（但是必须保持键的唯一性）

TreeMap不允许键为空

2.TreeMap中的映射关系具有一定的顺序，它会帮助我们进行排序

因此在添加、删除、定位映射关系时，效率较HashMap差

3.HashMap数据结构基于哈希表，TreeMap数据结构基于树

在实际使用时，建议都使用HashMap，除非需要排序的Map时才用TreeMap

知识点4：HashMap和TreeMap中的常用方法

初始化

HashMap<Integer, String> hashMap = new HashMap<>();

增

hashMap.put(1,"123");
hashMap.put(2,"234");
hashMap.put(3,"345");

删

hashMap.remove(3);

查

System.out.println(hashMap.get(2));
if(hashMap.containsKey(1))
    System.out.println("存在键1");
if(hashMap.containsValue("123"))
    System.out.println("存在值123");

改

if(hashMap.containsKey(1))
    hashMap.put(1,"555");
System.out.println(hashMap.get(1));

遍历

for (Integer i : hashMap.keySet()) {
    System.out.println(hashMap.get(i));
}
for (String str : hashMap.values())
{
    System.out.println(str);
}

总结

Java中的Map集合类似C#中的Dictionary字典

我们在使用时，建议主要使用HashMap，它的效率高于TreeMap

Java异常处理

知识点1：Java中的异常捕获和C#中使用基本一致

语法：

try{
    //需要进行异常捕获的代码块
}
catch (NullPointerException ex)
{
    //ex.getMessage()
    //捕获异常信息
}
catch (ArrayIndexOutOfBoundsException ex)
{
    //ex.getMessage()
    //捕获异常信息
}
catch (Exception ex)
{
    //ex.getMessage()
    //捕获异常信息
}
finally {
    //不管之前的代码块是否发生异常
    //finally中的内容都将执行
    //注意：以下几种情况下finally中内容不会执行
    //1.finally 语句块中发生异常
    //2.在finally之前执行了System.exit()退出程序
    //3.程序所在的线程销毁
    //4.关闭CPU
}

知识点2：Java中的常见异常类

NullPointerException:空指针异常
IOException:输入输出异常
FileNotFoundException:文件为找到异常
ArrayIndexOutOfBoundsException:数组越界异常
NegativeArraySizeException:数组元素个数为负数抛出异常
ClassCastException:类型转化异常
ArithmeticException:算数异常
ArrayStoreException:数组包含不兼容的值抛出的异常
ClassNotFoundException:未找到相应类异常

等等

知识点3：Java中自定义异常

继承Exception异常基类

实现一个有参构造函数

通过throw关键字自己抛出异常对象

try
{
    int i = -3;
    if(i < 0)
    {
        MyException ex = new MyException("数组容量不合法");
        ex.i = i;
        throw ex;
    }
    int[] ints = new int[i];
}
catch (MyException ex)
{
    System.out.println(ex.getMessage() + "；数组容量为：" + ex.i);
}
finally {
    System.out.println("异常捕获结束");
}

知识点4：方法中抛出异常

如果某个方法可能发生异常，但是又不想再方法内处理这个异常

想在调用这个方法的外部进行处理

可以使用throws关键字在声明方法时抛出可能的异常

多个异常可以使用逗号分割

那么外部调用该方法时，发生对应异常时即可进行处理

注意：

继承时，覆盖有抛异常的方法时，该方法必须抛出相同的异常或者异常的子类

如果父类中方法抛出多个异常，那么子类的覆盖方法必须抛出那些异常的子集，不能抛出新异常

  public static void Test() throws ArrayIndexOutOfBoundsException,NegativeArraySizeException
    {
        int[] ints = new int[-3];
    }

try
{
    Test();
}
catch (NegativeArraySizeException ex)
{
    System.out.println("容量为负了");
}
catch (ArrayIndexOutOfBoundsException ex)
{
    System.out.println("索引越界");
}

C#不支持这种写法，但是允许在方法体里面直接抛出异常，如下：

public void myMethod() {
    throw new RuntimeException("发生了一个运行时异常。");
}

总结

Java中的异常捕获和C#中基本一致

需要时直接使用即可

Java lambda表达式

知识点1：Java中 lambda表达式语法

基本结构：

(参数)->{代码块}

基于基本结构的写法：

()->{代码块}
()->结果表达式（相当于返回值）;
(参数)->{代码块}
参数->{代码块}
参数->结果表达式（相当于返回值）;
(参数1,参数2,参数3...)->{代码块}
(参数1,参数2,参数3...)->结果表达式（相当于返回值）;

知识点2：用于装载lambda表达式的函数式接口

函数式接口指仅仅包含一个抽象方法的接口

声明函数式接口后，我们可以用以下语法来使用lambda表达式

接口名变量名 = lambda表达式

注意：

lambda表达式的结构必须和函数式接口中声明的方法一致（返回值，参数数量）

ITest t = ()->{
    int i = 1;
    int i2 = 2;
    return i + i2;
};

System.out.println(t.Test());

ITest2 t2 = (a,b)->{
    System.out.println(a);
    System.out.println(b);
};

t2.Test(10, "123");

int value1 = 10;

知识点3：lambda表达式调用外部变量

1.和C#不同，无法更改局部变量的值,只有在局部变量没有被修改（编译器会自己判定在调用前有没有被修改过），或者设置成final的时候可以调用。

2.可以更改外部类的成员变量的值

t = ()->{
    value2 = 100;
    return value2;
};
System.out.println(t.Test());

闭包陷阱

C#的闭包可以随便捕获局部变量，而由于底层编译问题，即使捕获到的是值类型也会在函数执行期有类似引用类型的性质，这常常会导致闭包陷阱这类错觉，如下，至于经典的for循环闭包陷阱就不举例了。

     public void ExecuteAction()
     {
         int t = 0;
         Action action = () => Debug.Log(t);
         t = 23;

         // 在函数执行周期内，局部变量 `t` 被闭包以一种特殊的方式捕获。这种特殊方式使得，
         // 即使 `t` 是一个值类型，其行为在闭包中表现得就像是按引用捕获一样。
         // 这样的设计允许闭包内部能够访问并反映 `t` 的最新值，而不仅仅是闭包创建时的值。
         // 因此，即便在闭包创建之后 `t` 的值被修改，闭包执行时也能反映出这一修改，
         // 这可能与一些开发者对于值类型变量的行为预期不同。

         // 这样处理的原因在于，这为闭包内部修改变量值，或者需要引用并更新全局变量的值的情况提供了支持。
         // 如果局部变量被完全按值类型处理，即仅获取变量的值拷贝，那么就无法满足上述需要闭包修改或实时反映变量最新状态的场景。

         action(); // 因此，这里打印的结果是23，反映了 `t` 被修改后的最新状态。
     }

也因为这些原因，Java无法在表达式里面取得For循环的i，也无法捕获一个会在函数内被二次修改的变量，所以相比C#，Java规避了闭包陷阱。

总结

Java中的lambda表达式和C#中区别很大

Java中没有委托和事件

只有通过函数式接口来存储lambda表达式来进行使用

Java 方法的引用和Function接口

知识点1：什么是方法的引用

使用函数式接口去装载我们在类中声明的方法

而不是lambda表达式

知识点2：如何进行方法的引用

需要调用的目标方法

这个参考类为下文调用的目标方法

public class Lesson22 {

    public Lesson22()
    {
        System.out.println("无参构造");
    }

    public Lesson22(int i)
    {
        System.out.println("有参构造" + i);
    }

    public static void Test()
    {
        System.out.println("方法调用");
    }

    public void Test2()
    {
        System.out.println("方法调用2");
    }

    //泛型方法
    static public<T> void Test3(T i)
    {
        System.out.println(i);
    }
}

引用静态方法

类名::静态方法名

ITest01 t = Lesson22::Test;
t.fun();

引用成员方法

对象名::成员方法名

Lesson22 l = new Lesson22();
ITest01 t2 = l::Test2;
t2.fun();

引用构造函数

1.无参和有参构造类名::new

ITest02 tt = Lesson22::new;
Lesson22 l2 = tt.fun();

ITest03 tt2 = Lesson22::new;
l2 = tt2.fun(99);

2.数组构造类名[]::new

 // 使用方法引用创建一个数组构造器的函数式接口实例。这里的构造器引用Integer[]::new会根据提供的大小参数来创建一个新的Integer数组。
        ITest04 tt4 = Integer[]::new; // 这里实际上是方法引用的语法糖，指向数组的构造函数，参数int代表数组的大小。

// 使用该接口的fun方法并传入9，从而创建了一个可以存储9个Integer元素的数组。
        Integer[] arr = tt4.fun(9); // 返回一个长度为9的Integer数组。

// 打印数组的长度，验证数组确实是根据提供的参数创建的。
        System.out.println(arr.length); // 输出9，说明数组的长度即为传入的参数值。

引用泛型方法

函数式接口的泛型和对应的泛型方法参数或返回值上一定要对应

ITest05<Integer> ttt = Lesson22::Test3;
ttt.fun(999);

知识点3：Function接口

我们再使用lambda表达式时都需要自己声明函数式接口用于装载

为了方便我们的使用，Java在java.util.function包中提供了预先定义好的函数式接口供我们使用

其中最常用的接口是 Function<T,R>接口

T:参数类型

R:返回值类型

调用方法：apply

Function<Integer,String> function = (a)->{
    a += 99;
    return a.toString();
};
System.out.println(function.apply(1));

注意：更多的写好的函数式接口可以直接去function包中查看

如果不想记忆，那直接自己写函数式接口即可

总结

不管是使用lambda表达式还是想要引用方法

我们都需要使用函数式接口来装载

除了Function以外Java中还写好了很多函数式接口供我们使用

用现成的还是自己写，自己决定即可

Java 常用类库

知识点1：常用类库指什么？

常用类库主要指Java中为了提升我们的开发效率

预先就已经写好的一些包，这些包中提供了很多常用类

目的是方便开发人员的使用，而无需再自己去实现

主要有以下内容

变量类型的包装类 Integer、Double、Boolean、Character、Number等
存储较大数据的 BigInteger类和BigDecimal类
数学计算类 Math
随机数类 Random

等等

了解他们提供的方法名，基本就知道如何使用了

知识点2：变量的包装类

Number类

它是Byte Integer Short Long Float Double类的父类

主要方法：

byteValue() 以byte形式返回指定的数值
intValue() 以int形式返回指定的数值
floatValue() 以float形式返回指定的数值
shortValue() 以short形式返回指定的数值
longValue() 以long形式返回指定的数值
doubleValue() 以double形式返回指定的数值

所有继承Number类的子类都具备以上方法

Integer类

它和Byte、Short、Long三个封装类方法基本相同

区别就是封装的是不同的数据类型

主要方法：

parseInt(String str) 将字符串转数值
toString() 将数值转字符串
toBinaryString(int i) 以二进制无符号整数形式返回一个整数参数的字符串表示形式
toHexString(int i) 以十六进制无符号整数形式返回一个整数参数的字符串表示形式
toOctalString(int i) 以八进制无符号整数形式返回一个整数参数的字符串表示形式
equals(Object integerObj) 比较两个对象是否相等
compareTo(Integer anotherInteger) 比较两个Integer对象，相等返回0；调用函数对象小于传入对象，返回负数；反之，返回正数

Double类

它和Float类的方法基本相同

区别就是封装的是不同的数据类型

主要方法：

parseDouble(String str) 将字符串转数值
toString() 将数值转字符串
isNaN() 如果该double值不是数字，返回true，否则返回false
compareTo(Double d) 和Integer类中方法作用一致
equals(Object doubleObj) 和Integer类中方法作用一致
toHexString(double d) 返回double参数的十六进制字符串表示形式

Boolean类

equals(Object obj) 和Integer类中方法作用一致
parseBoolean(String s) 将字符串转Boolean
toString() 将数值转字符串
valueOf(String s) 返回一个用指定的字符串表示的boolean值

Character类

compareTo(Character anotherCharacter) 比较两个Character对象，若两个对象相等则返回0
equals(Object obj) 和Integer类中方法作用一致
toString() 转字符串
toUpperCase(char ch) 将字符转大写
toLowerCase(char ch) 将字符转小写
isUpperCase(char ch) 判断字符是否是大写
isLowerCase(char ch) 判断字符是否是小写
isLetter(char ch) 判断字符是否是字母
isDigit(char ch) 判断字符是否为数字

知识点3：大数据类

BigInteger

该类主要用于存储任意大小的整数，也就是说它可以表示任何大小的整数值而不会丢失信息

因为传统的整形类型都有最大最小区间，而该类没有，主要用于存储大数据

主要方法：

add(BigInteger val) 加法
subtract(BigInteger val) 减法
multiply(BigInteger val) 乘法
divide(BigInteger val) 除法
remainder(BigInteger val) 取余
pow(int exponent) 计算exponent次方
negate() 取反
shiftLeft(int n) 左移n位
shiftRight(int n) 右移n位
and(BigInterger val) 位与
or(BigInteger val) 位或
compareTo(BigInteger val) 比较，类似Integer中
equals(Object x) 判断数值是否相等
min(BigInteger val) 取最小
max(BigInteger val) 取最大、

BigDecimal

该类和BigInteger用于表示大数据，但是它主要用于表示浮点数（有小数点的数值）

它的主要方法和BigInteger类似

知识点4：数学计算类

Math类

提供众多数学函数方法，方便我们进行数学计算

主要包含三角函数、指数函数、取整函数、最大值、最小值、平均值等等

这些方法都是静态方法，都通过Math点出使用

主要方法：

三角函数

sin(double a) 正弦
cos(double a) 余弦
tan(double a) 正切
asin(double a) 反正弦
acos(double a) 反余弦
atan(double a) 反正切
toRadians(double angdeg) 角度转弧度
toDegrees(double angrad) 弧度转角度

指数

exp(double a) 获取e的a次方
log(double a) 取自然对数
log10(double a) 取底数为10的a的对数
sqrt(double a) 取a的平方根
cbrt(double a) 取a的立方根
pow(double a, double b) 取a的b次方

取整

ceil(double a) 向上取整
floor(double a) 向下取整
rint(double a) 返回与a最接近的整数，如果有两个，取偶数
round(float a) 将参数a加上0.5后返回与其最近的整数
rount(double a) 将参数a加上0.5后返回与其最近的整数，然后强转为Long

其他

max(参数1，参数2) 最大值
min(参数1，参数2) 最小值
abs(参数) 绝对值

知识点5：随机数类

Random

用于生成随机数的类

主要方法：

Random r = new Random(); 以当前系统时间作为随机数生成器种子
Random r = new Random(seedValue); 自己设置随机数种子
nextInt() 返回一个随机整数
nextInt(int n) 返回大于等于0且小于n的随机整数
nextLong() 返回一个随机长整型
nextBoolean() 返回一个随机布尔值
nextFloat() 返回一个随机单精度浮点
nextDouble() 返回一个随机双精度浮点
nextGaussian() 返回一个概率密度为高斯分步的双精度浮点

知识点6：其他类

Data：日期类获取日期时间相关方法
Calendar：日历类比起Date更加国际化
System:系统类有获取当前时间的方法

等等

总结

Java中提供了很多现成的类和方法供我们使用

对他们产生印象，当自己开发时有类似需求时

直接使用他们，可以提升我们的开发效率

如果觉得文章对你有用，请随意赞赏

Java语法

http://www.klned.com/archives/1712483596258

作者

Zhang

发布于

2024-04-08

更新于

2024-04-16

许可协议

CC BY 4.0

Java语法

环境和编译器设置

导入

知识点1：设置中文

知识点2：字体和大小

知识点3：注释

知识点4：注释颜色修改

知识点5：折叠代码

知识点6：文件编码

Java变量相关

知识点1：Java中的有符号整型

知识点2：Java中的浮点型

知识点3：Java中的其它类型

知识点4：Java中的常量

总结

Java运算符

知识点1：赋值运算符

知识点2：算数运算符

知识点3：自增减运算符

知识点4：比较运算符

知识点5：逻辑运算符

知识点6：位运算符

知识点7：三目运算符

知识点8：运算符优先级

总结

Java 条件分支语句

知识点1：条件分支——if语句

Java循环语句

知识点1：while循环

知识点2：do while循环

知识点3：for循环

知识点4：foreach语句

知识点5：break和continue

总结

Java 数组

知识点1：一维数组

声明

注意： Java中的数组申明比C#中多一种方式

初始化

遍历

知识点2：二维数组

声明：

初始化

遍历

知识点3：交错数组

初始化和声明

遍历

总结

Java 中Arrays类的静态方法

知识点1：Arrays类是什么

知识点2：填充替换数组元素

知识点3：数组排序

知识点4：复制数组

知识点5：查询数组

Java函数

知识点1：Java中的函数和C#对比

知识点2：复习函数基本概念

知识点3：Java的函数写在哪里

知识点4：Java基本语法

修饰符

返回类型

函数名

参数

return

知识点5：实际运用

Java 面向对象—封装

知识点1：面向对象回顾

知识点2：Java中类的封装

演示类

注意——关于静态类

总结

Java 面向对象—继承

知识点1：Java中继承和C#中的相同点

知识点2：Java中 继承的写法

知识点3：万物之父Object中的关键方法

知识点4: 父子类的上下转换（里氏替换原则）

知识点5：instanceof关键字

总结

Java 面向对象—多态

知识点1: Java中的vob

知识点2：Java中继承的写法