Java从入门到精通思维导图模板_ProcessOn思维导图、流程图

初识Java

Java简介

Java是一种通用的，基于类的，面向对象的编程语言。它是用于应用程序开发的计算平台。因此，Java是快速，安全和可靠的。它被广泛用于在笔记本电脑，数据中心，游戏机，科学超级计算机，手机等中开发Java应用程序。Java遵循WORA（Write Once, Run Anywhere。一次写入，到处运行）的原理，并且与平台无关。它也简单易学。

Java的应用领域

Android应用

金融服务行业的服务器应用程序

Java Web应用程序

软件工具

交易应用程序

J2ME应用

嵌入式空间

大数据技术

高频交易领域

科学应用程序

Java的版本

怎么学好Java

JavaAPL文档

Java语言的特性

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

搭建Java环境

熟悉eclipse开发工具

熟悉eclipse

eclipse简介

Eclipse 是一个开放源代码的、基于Java的可扩展开发平台。就其本身而言，它只是一个框架和一组服务，用于通过插件组件构建开发环境。幸运的是，Eclipse 附带了一个标准的插件集，包括Java开发工具（Java Development Kit，JDK）。

下载Eclipse 

Eclipse的配置与启动

使用eclipse

Java语言基础

Java主类结构

Java语言是面向对象的程序设计语言，Java程序的基本组成单元是类，类体中又包括属性和方法两部分。每个应用程序都必须包含一个main()方法，含有main()方法的类称为主类。 对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。 类：类是一个模板，它描述一类对象的行为和状态。 方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。 实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定

基本数据类型

变量与常量

关键字：又称保留字，是Java中已经被赋予特定意义的一些单词，不能被作为标识符来使用。

常量：在程序运行过程中一直不会改变的量，只能被赋值一次。

变量：可以多次赋值，分为局部变量和成员变量，局部变量优先级高于成员变量，就近原则。

成员变量：在类体中所声明的变量被称为成员变量，它在整个变量都有用。

局部变量：在类的方法体中声明的变量，它只在当前代码块中有效。

运算符

赋值运算符：“=” "="：将右方操作数所含的值赋给左方。

算术运算符"+"：加 "-"：减 "*"：乘 "%"：取余 "/"：除

自增和自减运算符："++","--" "++"：自增 "--"：自减 符号在前先运算再使用，符号在后先用再运算

比较运算符：">","<","==",">=","<=","!=" ">"：大于 "<"：小于 "=="：等于 ">="：大于或等于 "<="：小于或等于 "!="：比较左右是否相等

逻辑运算符："&&","||","!" "&&"逻辑与:从左往右，两者都为真，结果才是真。 "||"逻辑或：从左往右，只要有一者为真，结果就是真。 "!"逻辑非:从右往左，非真即假，非假即真。

位运算符："&","|","~","^","<<",">>",">>>" "&"与：两者都为1，结果才是1。 "|"或：只要有一者为1，结果就是1。 "~"取反：0变1，1变0。 "^"异或：两者相同即为0，不同为1。 "<<"左移：空位补0，溢出去掉。 ">>"右移：正数补0，负数补1溢出去掉。 ">>>"无符号右移：整体右移，空位补0，溢出去掉。

三元运算符："? :" 三元运算符的使用格式为：条件式 ？ 值1 ： 值2 三元运算符在底层逻辑和if语句是一样的

运算符优先级： 从先到后分别是：赋值运算符>逻辑运算符>比较运算符>算术运算符>增量和减量运算

数据类型转换

隐式类型转换（自动类型转换）：从低级类型转向高级类型的转换，系统将自动转换，而且这个过程一定不会丢失数据

流程控制

复合语句

Java语言的复合语句是以整个块区为单位的语句，所以又称块语句。复合语句由开括号“｛”开始，闭括号“｝”结束。

条件语句

if条件语句

Switch多分支语句

循环语句

while循环语句

do..whlie循环语句

for循环语句

循环控制

break语句      跳出本次循环

continue语句         跳过本次循环

数组

数组概述

数组是具有相同数据类型的一组数据的集合

一维数组

创建一维数组

声明一维数组的两种方式 数组元素类型 数组名字【】； 数组元素类型【】 数组名字； 例：int arr【】； 分配内存 数组名字=new 数组元素的类型【数组元素的个数】 例：arr=new int【5】； 声明同时为数组分配类型 数组元素的类型 数组名=new 数组元素的类型【数组元素的个数】； 例：int month[]=new int[12];

初始化一维数组

两种初始化方式 int arr[]=new int[]{1,2,3,4,5}; int arr[]={34,23,12,6};

.length自动输出数组长度

使用一维数组

结果

二维数组

创建二维数组

声明二维数组 数组元素类型 数组名字【】【】； 数组元素类型【】【】 数组名字； 例：int a[][]; 分配内存 a=new int[2][4]; 分别为每一组分配内存 a=new int[2][]; a[0]=new int[2]; a[1]=new int[3]; 声明的同时分配内存 int a=new int[2][4]

初始化二维数组

数组数据类型  数组名称【】【】={数组元素1，数组元素2，......数组元素}； 例:int myarr[][]={{12,0},{45,10}};

使用二维数组

结果

数组的基本操作

遍历数组

结果

填充替换数组元素

1，fill(int[] a,int value) a:要进行元素替换的数组 value:要储存数组中的所有值 Arrays.fill(数组名，值); 替换数组部分元素:前改 后不改 Arrays.fill(数组名，前索引，后索引，值);    2,fill(int[] a,int fromlndex,int value) a:要进行填充的数组 fromlndex:要使用指定值填充的第一个元素的索引（包括） tplndex:要使用指定值填充的最后一个元素的索引（不包括） value:要分配给数组指定范围中的每个元素的值

查询数组

binarySearch(Object[] a,Object key) a:要搜索的数组 key:要搜索的值 查询数组元素:先排序再查询 索引 = Arrays.binarySearch(数组名，元素);  查询数组元素:先排序 再查询 前含 后不含 索引 = Arrays.binarySearch(数组名，前索引，后索引，元素);

复制数组

copyOf(arr,int newlength) 复制数组元素:空位补 溢出去掉 新数组名 = Arrays.copyof(旧数组名，新数组长度);    复制数组部分元素:前在 后不在 新数组名 = Arrays.copyofRange(旧数组名，前索引，后索引);

对数组进行排序

数组元素排序 Arrays.sort(数组名）

数组排序算法

冒泡排序

对比相邻的元素值，满足条件就交换元素值，小的向前，大的向后

结果

直接选择排序

直接选择最大或最小的值放在最后

结果

反转排序

中间不动 两边互换

结果

类和对象

面向对象概述

对象

对象是对事物的实例化，例如 人、鸟、电脑、手机等。这些都可以是看作是一个对象。 通常对象会被分为两部分，静态部分与动态部分。 静态部分就是一个事物必然拥有的部分，这个部分被称为属性，任何对象就会有属性。 而动态部分就是一个事物特有的部分，这个部分被称为行为，行为可以是对象独有的，也可以是都有的。

类

声明一个类需要通过一个关键字class 3、类与对象的关系 1）类是对某一类事物的描述，是抽象的、概念上的意义，对象是实际存在的该类事物的每一个个体，也被称为实例。

封装

在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。 封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。 要访问该类的代码和数据，必须通过严格的接口控制。 封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。 适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

继承

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为

多态

多态是同一个行为具有多个不同表现形式或形态的能力。                多态就是同一个接口，使用不同的实例而执行不同操作。

类

成员变量

在Java中，对象的属性就是成员变量的方式存在的。   其实成员变量就是普通的变量，只不过用来表示了类的属性。在创建成员变量时，可以为成员变量设定初始值，如果设定初值的话，会有默认值。如果在创建成员变量时，给定了默认值，那么在本类创建的所有对象，在没有修改这个成员变量的值前，所有对象的成员变量都是这个给定值。

成员方法

在Java中使用成员方法来对应类对象的行为。以上述的Book类为例。 它包含了两个成员方法，一个是设置图书的名称，一个是获取图书的名称 定义成员方法的格式  权限修饰符 返回值类型 方法名(参数类型 参数名){  //方法体  return 返回值; } 成员方法的定义，其实与方法的定义没区别，只不过成员方法是对应着类对象的行为。

权限修饰符

权限修饰符用于控制外界对类或类中的事物的访问。 Java提供了三种权限修饰符，分别是：public、private、protected。这三种权限修饰符控制着外界对被修饰事物的访问。     特别说明，如果类或方法或成员变量前没有加任何权限修饰符，那么就是默认权限default。

局部变量

定义在方法内部的变量称为局部变量。局部变量的定义和使用，与普通的变量一致。 局部变量在方法被执行时创建，在方法结束时销毁。局部变量在使用前必须进行赋值或者初始化。

this关键字

this关键字只能在本类中使用。 this关键字表示对象当前调用者的地址。

类的构造方法

在类中，除了成员方法之外，还有一类特殊的方法，就是构造方法。构造方法是一种于类同名的方法。 在一个类创建对象时，虚拟机会根据形参，自动调用构造方法，来初始化对象。 构造方法没有返回值，且构造方法的名称要与本类同名。同时满足这两点才是一个构造方法。 无参构造与有参构造  这里的有参与无参，指的是有无形参。

静态变量和静态方法

使用static关键字修饰的方法或者变量称为静态的。 被static修饰的变量与方法，地址被放置于静态区内，在类文件执行时，会自动调用这块区域，且只会执行一次。 静态方法与变量可以直接使用 类名.静态成员 的方式调用。 静态关键字使用注意点 在静态方法中不可能使用this关键字 静态方法只能调用静态方法，非静态方法调用所有 局部变量不可以使用static关键字声明 主方法必须使用static声明 所有类，只有内部类可以使用static关键字声明

类的主方法

主方法是类的入口点，它定义了程序从何处开始；主方法提供对程序流向的控制，Java编译器通过主方法来执行程序。主方法的定义中包含的特性： ·主方法是静态的，如果要直接在主方法中调用其他方法，则该方法也必须是静态的 ·主方法没有返回值 ·主方法的形参我数组，其中args[0]~args[n]分别代表程序的第一参数到第n个参数，可以使用args.length获取整个采纳数的个数。

对象

对象的创建

访问对象的属性和行为

每个对象都有自己的属性和行为，这些属性和行为在类中体现为成员变量和成员方法，其中成员变量对应对象的属性，成员方法对应对象的行为。 在 Java 中，要引用对象的属性和行为，需要使用点（.）操作符来访问。对象名在圆点左边，而成员变量或成员方法的名称在圆点的右边。语法格式如下： 对象名.属性(成员变量) // 访问对象的属性 对象名.成员方法名() // 访问对象的方法

对象的引用

对象的销毁

继承，多态，抽象类与接口

类的继承

在Java语言中，一个类继承另一个类需要使用关键字extends，关键字extends的使用方法如下： class Child extends Parent{}  因为Java只支持单继承，所以一个类只能有一个父类。 子类在继承父类之后，创建子类对象的同时也会调用父类的构造方法。  允许多重继承 class A{} class B extends A{} class C extends B{ } 子类继承父类后，在创建子类对象的同时，会先调用父类的构造方法。

object类

Object类是Java中的顶级父类，在Java中所有类都直接或间接的继承与Object类，它是所有类的父类 在Object类中有很多Java已经帮我们定义好了的方法，下面就简单介绍几个。 toString() 方法 toString() 方法的功能是 将一个对象返回为字符串形式，它会返回一个String类型的实例。 调用方式 类名.toString();

equals() 方法 在Java中，== 比较符，在比较基本数据类型时，比较的是数据值是否相等。 而在比较引用数据时，比较的就是两个引用数据的地址值是否相同了。 (使用new操作符创建的都是引用数据类型) 注意，在使用equals() 方法比较自行编写的类对象时，那么需要先重写equals方法，因为每个类判相等的规则都是不一样的。而且如果没有重写的话，那么系统会自动调用Object中的equals方法。

对象类型的转换

向上转型

向上转型可以理解为将子类类型的对象转换为父类类型的对象，即把子类类型的对象直接赋值给父类类型的对象，进而实现按照父类描述子类的效果。  对象之间的类型转换在Java编程中还是很常见的。类型转换分为向上转型与向下转型。 而向上转型就是将子类对象赋值给父类对象。 格式为： 父类 对象名 = (父类) 子类对象; 需要注意得是，在进行向上类型转换后，父类对象依旧无法调用子类独有的属性与方法。 只能调用从父类中继承下来的属性与方法。 需要注意的是，只有具备继承关系得类与类之间才能进行对象类型转换，非继承关系之间不能进行类型转换。

向下转型

向下类型转换可以理解为将父类类型的对象转换为子类类型的对象。 但是运用向下转型，因为父类大多是较为抽象的类，而子类大多是具体的类， 而将一个较为抽象的类转换为一个较为具体的类，这样的转换通常会出现错误，所以向下转型是不安全的。 在进行向下转型时，需要借助强制类型转换。 子类类型 子类对象 = (子类类型) 父类对象;  父类对象可以强制类型转换为子类对象，但是有一个前提：这个父类对象要先引用这个子类对象。

使用instanceof关键字判断对象类型

instanceof关键字可以判断是否一个类实现了某个接口，也可以判断一个实例对象是否属于一个类 instanceof 的语法格式如下： myobject instanceof ExampleClass myobject:某类的对象引用 ExampleClass:某个类

方法的重载

重载 方法名不同 参数不同

结果

final关键字

final变量

Final修饰变量———不可改变的量（常量） 例题7.10： public class FinalData{     static fina double PI = 3.1415926;       public static void main(String[] args){         System.out.println("圆周率的值为：" + PI);         System.out.println("半径为3的圆的周长为：" + (2 * 3 * PI));         //尝试修改PI的值         PI = 3.1415927;     } }

final方法

public final void test(){ ...//省略一些程序代码 } 例题7.11：  package seven;   public class Dad {  public final void turnOnTheTV() {   System.out.println("爸爸打开了电视");  } } class Bady extends Dad{  public final void turnOnTheTV() {   System.out.println("宝宝也要打开了电视");  } }

final类

final 类名{}

多态

利用多态可以使程序有良好的扩展性，并可以对所有类对象进行通用的处理。

抽象类与接口

接口

接口是抽象类的延伸，可以将它看作是纯粹的抽象类，接口中的所有方法都没有方法体

抽象类

instanceof 对象名 instanceof 类名       判断对象是否属于该类或其子类 对象名 instanceof 接门名        判断对象是否属于该接口的实现类 抽象方法 修饰符 abstract 返回参数 方法名(传入参数) 抽象类 有抽象方法的类一定是抽象类 修饰符 abstract class 类名{ } 接口 所有方法都是抽象方法 修饰符 interface 接口名{ } 实现 implements Java语言每个类可以实现多个接口 修饰符 class 类名 implements 接口1,接口2,...{ }}

包和内部类

Java类包

类名冲突

简单来说，Java类名冲突，就是指package xxx.yyy.zzz下的类名以及import aaa.bbb.ccc.类名之间的冲突。

除此外，还有同一个包下同级出现同名的类以及导入两个类重名时都算类冲突。前者是Java语法基本要求之一，压根就不能这样写

完整的类路径

类的定义规定，在同一个类包下面不允许出来同名的类，但是在不同类包下面就允许出现这种情况，相当于将两个同名的类放入了不同的盒子内，避免出现这个问题。 如果一个程序内存在多个同名不同包的max类，那么该如何使用指定包的类呢？ 在使用该类时使用该类的类路径，也成为绝对路径

创建包

在进行创建包的时候需要注意的是，Java包的命名规则建议使用全小写字母进行命名。 需要了解的是如果一个类没有被定义在一个指定的包内，那么该类就被归纳到默认包(default package)中。 在某个包下面创建一个类的话，需要在这个类的开头加上表达式 package 包名，该表达式需要放置在程序的第一行，使用package关键字指定包名之后，包名也会成为类名的一部分，在不同包下使用该类的话，需要使用 import 包名.类名 的格式。

导入包

在Java中，如果需要使用到其它包内的类的话，除了使用该类的绝对路径之外，我们还可以使用Java中 import 关键字来指定。例如，如果在其它包内也定义了一个Math，那么假如我们只想使用该Math类的话，那么我们可以使用import关键字进行导包。、】需要注意的是，如果使用import导入某个包下的所有类时，这些类并不包括该包下的子包的类。如果需要使用子包中的类时，需要对子包进行单独引用。

使用import关键字还可以对静态方法与静态变量进行导包。

内部类

成员内部类

成员内部类 定义在一个类成员位置的内部类，称为成员内部类，在成员内部类中可以使用外部类的的任意成员变量与成员方法，即使该外部类成员变量被private所修饰。   package test;   public class Demo_4 {     private int num;     static int i=0;          // 内部类      class test{         public void show(){             // 内部类调用外部类的成员变量             System.out.println(num);             System.out.println(i);         }     } } 因为private等权限修饰符是针对外界的调用而进行权限判断的，但是成员内部类定义在该类的内部，那么相对于该类的一部分，就像该类的方法也是可以调用被private修饰的成员变量一般，成员内部类属于外部类的成员之一。 内部类是依赖于外部类的存在而存在。除非程序中已经有了一个外部类的对象，否则内部类一般不会单独存在。 两种方法： 对外部类编写get方法，对外提供内部类的对象 如果内部类没有被private修饰，那么可以在外界创建一个内部类的对象； 外部类与内部类之间也可使用this关键字，如果在内部类中需要使用到外部类的成员变量，那么可以使用外部类.this.变量名的方式使

匿名内部类

匿名内部类本质是一个隐藏了名字的内部类。匿名类是只有在创建时才会编写类体的一种写法 public class Demo_4{     public static void main(String[] args) {         // 匿名内部类         new Swit(){             @Override             public void swit(){                 System.out.println("重写了swit方法");             }         };     } } interface Swit{     public void swit(); }   匿名内部类编译后会产生一个以 “外部类名$序号“ 为名称的 .class文件，序号以1-n排列，分别代表1-n个匿名内部类。那么我们可以找到这个.class文件，并对其进行反编译来查看我的结论是否正确。 上述反编译的结果可以说明，使用匿名内部类的格式创建的是一个匿名内部类的对象，而大括号内{}的才是匿名内部类的类体。 1.匿名内部类的对象如果没有赋值给任何引用变量的话，该对象会在使用后被Java虚拟机自动销毁。 2.匿名类不能写构造方法。 3.匿名类不能定义静态的成员。 那么匿名内部类对象可以赋值给那些引用变量呢？可以被赋值给被继承的接口或者父类对象。形成多态

异常处理

异常概述

在程序中，可能会因为各种程序员预料不到的异常出现，也可能由超过程序员可控范围的环境因素产生，如用户的坏数据，试图打开一个根本不存在的文件等，在java中，被称为异常，

异常的抛出与捕捉

抛出异常

通常，为了保证程序有效的运行，需要对抛出的异常进行相应的处理 例题9.2 package dibazhang;   public class liti9_2 {    public static void main(String[] args) {   //数字格式异常 //  try {    String str = "lili";    System.out.println(str + "年龄是:");    int age = Integer.parseInt("20L");    System.out.println(age); //  }catch(NumberFormatException e){ //   System.out.println("！！出现数字格式异常！！"); //   System.out.println("请联系管理员进行修复"); //  } //  finally { //   System.out.println("程序结束"); //  }    }   }  结果：

捕捉异常

try，catch语句就是用来捕捉和处理异常的 语法： try{     //程序代码块 } catch（Exception1 e）{       //对Exception1的处理   } catch（Exception2 e）{       //对Exception2的处理 }... finally{     //程序代码块 }

例题package dibazhang;   public class liti9_2 {    public static void main(String[] args) {   //数字格式异常   try {//try语句块中包含可能出现异常的程序代码    String str = "lili";//定义字符串变量    System.out.println(str + "年龄是:");//输出的信息    int age = Integer.parseInt("20L");//数据类型转换    System.out.println(age);   }catch(NumberFormatException e){//catch语句块用来获取异常信息    System.out.println("！！出现数字格式异常！！");    System.out.println("请联系管理员进行修复");//输出信息   }  } } 结果：

finally语句：无论程序是否出现异常，都会执行finally语句，但是在以下四种情况不会执行finally语句块 1.在finally语句块中出现异常 2.在前面的代码块中使用了System.exit()退出程序 3.程序所在线程死亡 4.关闭cpu

Java常见的异常类

异常 说明 ClassCastException 类型转换异常 ClassNotFoundException 未找到相应类异常 ArithmeticException 算术异常 ArraylndexOutOfBoundsException 数组下标越界异常 ArrayStoreException 数组中包含不兼容的值抛出的异常 SOLException 操作数据库异常类 NullPointerException 空指针异常 NoSuchFieldException 字段未找到异常 NoSuchMethodException 方法未找到抛出的异常 NumberFormatException 字符串转换为数字抛出的异常 NegativeArraySizeException 数组元素个数为负数抛出的异常 StringlndexOutOfBoundsException 字符串索引超出范围抛出的异常 OException 输入输出异常 lllegalAccessException 不允许访问某类异常 InstantiationException 当应用程序试图使用Class类中的newinstance0方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常 EOFException 文件已结束异常 FileNotFoundException 文件未找到异常

自定义异常

用户只需要继承Exception类即可自定义异常类，大体可以分为以下几个步骤 1.创建自定义异常类 2.在方法中通过throw关键字抛出异常对象 3.如果在当前抛出异常的方法中处理异常，可以使用try-catch语句块捕获并处理，否则在方法的声明处通过throw关键字指明要抛出给方法调用者的异常，继续进行下一步操作

package dijuizhang;   public class MyException extends Exception{//创建自定义异常类，继承Exception类  public MyException(String message) {//构造方法   super(message);  //父类构造方法  } } 现在我们创建好自定义异常类了，我们再写一个小程序来使用异常类

package dijuizhang;   public class Tran {//创建类  static int avg(int num1,int num2) throws MyException{   //定义方法，抛出异常   if(num1 < 0 || num2 < 0) {//判断方法中参数是否满足指定条件 //   System.out.println("存在负数，无法计算");    throw new MyException("存在负数，无法计算");//错误信息   }   if(num1 > 100 || num2 > 100) {//判断方法中参数是否满足指定条件 //   System.out.println("大于100，无法计算");    throw new MyException("大于100，无法计算");//错误信息   }   return (num1 + num2) / 2;//将参数的平均值返回  }  public static void main(String[] args) {//主方法   try {  //try语句块处理可能出现的异常代码   int result = avg(132,56);//调用avg方法   System.out.print(result);//将avg方法的返回值输出   }catch(MyException e){    System.out.print(e);//输出异常信息   }  }     }

在方法中抛出异常

使用throws关键字抛出异常

throws关键字通常被用于声明方法时，用来指定可能抛出的异常，多个异常可使用逗号分隔

例题：package dijuizhang;   public class liti9_6 {  static void pop() throws NegativeArraySizeException{   //定义方法并抛出NegativeArraySizeException异常   int[] arr = new int[-3];//创建数组  }  public static void main(String[] args) {//主方法   try {  //try语句处理异常信息    pop(); //调用pop方法   }catch(NegativeArraySizeException e) {    System.out.print("pop()方法抛出的异常");//输出异常信息   }  }   }

结果：

使用throw关键字抛出异常

throw通常用于方法体中，并且抛出一个异常对象，程序在执行到throw语句立刻中断，它后面的语句不会执行

例题9.7 package jiudanyuan;   public class MyException extends Exception{//创建自定义异常类  String message;//定义String类型变量  public MyException(String ErrorMessagr) {//父类方法   message = ErrorMessagr;  }  public String getMessage() {//覆盖getMessage方法   return message;  } }

例题9.8 package dijuizhang;   public class liti9_8 {  static int quotient(int x,int y) throws MyException {   //定义方法抛出异常   if(y < 0) {//判断参数是否小于0    throw new MyException("除数不能为负数");//异常信息   }   return x / y;//返回值  }  public static void main(String[] args) {//主方法   try {  //try语句块包含可能发生异常的语句    int result = quotient(3,1);//调用puotient方法   }catch(MyException e) {//处理自定义异常信息    System.out.println(e.getMessage());//输出异常信息   }catch(ArithmeticException e) {//处理ArithmeticException异常    System.out.println("除数不能为0");//输出提示信息   }catch(Exception e) {//处理其他异常    System.out.println("程序发生了其他异常");//输出提示信息   }  }   }

运行时异常

RuntimeException异常时程序运行中抛出的异常，java类库的每个包中都定义了异常类所有这些类都是Throwable类的子类，Throwable类派生了两个子类，分别是Exception类和Error类，Error类及其子类用来描述java运行系统中的内部错误以及资源耗尽的错误，这类错误比较严重，Exception类称为非致命性类，可以通过捕捉处理来使程序继续执行，Exception类又根据错误发生的原因分为 RuntimeException异常和除 RuntimeException异常之外的异常。

异常的使用原则

java异常强制用户考虑程序的强健性和安全性，异常处理不应用来控制程序的正常流程，其主要作用是捕获程序在运行时发生的异常并进行相应处理，编写代码处理某个方法可能出现异常时，可遵循以下几条原则 1.在当前方法声明中使用try-catch语句捕获异常 2.一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或者异常的子类

字符串

string类

单个字符串可以使用char类型保存，多个字符串组成的文本就需要保存在string对象中。string通常被称为字符串，一个string对象最多可以保存（2^32-1）个字节（占用4GB空间大小）的文本内容

声明字符串

str = "你好";         str = new String("你好");//10和11行输出结果一致 String:指定该变量为字符串类型 str:任意有效的标识符，表字符串变量的名称

创建字符串

String(char a[])该方法用一个字符数组ch创建String对象 char[] ch = {'g','o','o','d'};         str = new String(ch);         //两者等价于 String ch = new String("good") String(char a[],int offset,int lenght)该方法提取字符数组c中的一部分创建一个字符串对象。参数offest表示开始截取字符串的位置，lenght表示截取字符串的长度。 String(char value)该构造方法可分配一个新的String对象，使其表示字符串数组参数中所有的元素连接的结果 char[] c = {'s','t','u','d','e','n','t'};         String s = new String(c);         //两者等价于 String s = new String("student")

除了以上几种使用String类的构造方法来创建字符串变量外，还可以通过将字符串常量的引用赋值给一个字符串变量来创建字符串，代码如下： String str1,str2; str1 = "we are students" str2 = "we are students"

连接字符串

连接多个字符串

public class join {//创建类    public static void main(String[] args) {//主方法   // TODO 自动生成的方法存根   String s1 = new String("春色绿千里");//声明String对象s1   String s2 = new String("马蹄香万家");//声明String对象s2   String s = s1 + "\n" + s2;//将对象s1,"\n"和对象s2连接并结果赋值给s   System.out.println(s);//将s输出  }   }

连接其他时间类型

public class link {    public static void main(String[] args) {   // TODO 自动生成的方法存根   int booktime = 4;//声明变量int型变量booktime   float practice = 2.5f;//声明的float型变量practice   //将字符串与整型，浮点型相连接，并输出结果   System.out.println("我每天花费"+booktime+"小时看书;"+practice+"小时上机练习");  }   }

获取字符串信息

获取字符串长度

获取字符串长度 使用string类的length（）方法可获取声明的字符串对象的长度：(str为字符串长度) str.length(); 获取字符串的长度： String str = "we are students"; int size = str.length();

字符串查找

1,indexOf(String s):该方法用于返回参数字符串s在指定字符串中第一次出现的索引位置 str.indexOf(substr)  str：任意字符串对象             sbustr：要搜索的字符串 String str = "we are students"; int size = str.indexOf("a");//变量size的值是3

lastindexOf(String str):该方法用于返回指定字符串最后一次出现的索引位置 str.lastindexOf(substr)  str：任意字符串对象             sbustr：要搜索的字符串

获取指定索引位置的字符

使用charAt()方法可将指定索引处的字符返回：  str.charAt(int index) str：任意字符串                  index:整数型，用于指定要返回字符的下标

字符串操作

获取子字符串

ubstring（int beginIndex）【前索引，后索引（前含后不含）】该方法返回是从指定的索引位置开始截取直到该字符串结尾的子串 str.substring(int beginIndex) beginIndex:指定从某一索引处开始截取字符串   代码如下： String str = "hello word"; String substr = str.substring(3);

substring(int beginIndex,int endIndex)：  该方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的子串。 substring(int beginIndex,int endIndex)  beginIndex:开始截取子字符串的索引位置             endIndex:子字符串在整个字符串中的结束位置

去除空格

trim()方法返回字符串的副本，忽略前导空格和尾部空格： str.trim()

public class Black {  //创建类   public static void main(String[] args) {//主方法    // TODO Auto-generated method stub    String str = "   java  class   ";//定义字符串str    System.out.println("字符串原来的长度："+str.length());    //教案str原来的长度输出    //将str去掉前导空格和尾部空格后的长度输出    System.out.println("去掉空格后的长度："+str.trim().length());   }   }

字符串替换

replace（）方法可实现将指定的字符或字符串替换成新的字符或字符串。 str.replace(CharSequence target,CharSequence replacement)  target:要替换的字符或字符串                replacement：用于替换原来字符串的内容

public class NewStr {  public static void main(String[] args) {   // TODO Auto-generated method stub   String str = "address";//定义字符串str   String newstr = str.replace("a", "A");   //将str中“a”替换成“A”并返回新字符串newstr   System.out.println(newstr);//输出  }   }

判断字符串的开始与结尾

startsWith()方法与endsWith()方法分别用于判断字符串是否以指定的内容开始或结束，这两个方法的返回值都是Boolean类型。 1，startsWith()方法   该方法用于判断当前字符串对象的前缀是否为参数指定的字符串结束 str.startsWith(String prefix) suffix:作为后缀的字符串

public class StartOrEnd {    public static void main(String[] args) {   // TODO 自动生成的方法存根   String num1 = "22045612";   String num2 = "21304578";   boolean b = num1.startsWith("22");//判断字符串num1是否以22开始   boolean b2 = num2.endsWith("78");//判断字符串num2是否以78结束   System.out.println("字符串num1是以‘22’开始的吗？"+b);   System.out.println("字符串num2是以‘78’结束的吗？"+b2);//输出信息  }   }

判断字符串是否相等

对字符串对象进行比较不能简单地使用比较运算符“==”，因为比较运算符比较的是两个字符串的地址是否相同。

即使两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然会返回false。使用比较运算符比较两个字符串，代码如下： String tom = new String("i am a student"); String jerry = new String("i am a student"); boolean b = (tom == jerry);         因此，要比较两个字符串内容是否相等，应使用equals()方法和equalsignorecase()方法。

equals()方法     如果两个字符串具有相同的字符和长度，则使用equals()方法进行比较时，返回true。否则，返回false。语法如下：  str.equals(String otherstr)

equalsIgnoreCase（）方法     忽略了大小写的情况比较两个字符串是否相等，返回结果为Boolean类型。语法如下： str.equalsIgnoreCase（String otherstr）

按字典顺序比较两个字符串

语法如下：  str.compearTo(String otherstr) 说明：compareTo（）方法只有在equals（）方法返回turn时才返回0.

public class Wordbook {    public static void main(String[] args) {   // TODO 自动生成的方法存根   String str = new String("b");   String str2 = new String("a");   String str3 = new String("c");   System.out.println(str + "compareTo" + str2 + ":"   + str.compareTo(str2));   System.out.println(str + "compareTo" + str3 + ":"     + str.compareTo(str3));  } }

字母大小写转换

toLowerCase()方法【转换小写】 str.toLowerCase()  toUpperCase()方法【转换大写】 str.toUpperCase()

public class UpAndLower {    public static void main(String[] args) {   // TODO 自动生成的方法存根   String str = new String("Oh My God");//创建字符串str   String newstr = str.toLowerCase();//使用toLower方法实行大小写转换   String newstr2 = str.toUpperCase();//使用toUpper方法实行大小写转换   System.out.println(newstr);//将转换后的结果输出   System.out.println(newstr2);  }   }

字符串分割

split（）方法  str.split() split(String sign,int limit)方法 str.split(String sign,int limit)

public static void main(String[] args) {   // TODO 自动生成的方法存根   String str = "192.168.0.1";   String[] firstArray = str.split("\\.");//按照"."进行分割，使用转义字符"\\."   String[] secondArray = str.split("\\.",2);//按照"."进行两次分割，使用转义字符"\\."   System.out.println("str的原值为：["+ str +"]");//输出str原值   System.out.print("全部分割的结果为：");//输出全部分割的结果   for(String a :firstArray) {    System.out.print("["+ a +"]");   }   System.out.println();   System.out.print("分割两次的结果：");//输出分割两次的结果   for(String a : secondArray) {    System.out.print("["+ a +"]");   }   System.out.println();  }   }

格式化字符串

String类的静态format()方法用于创建格式化的字符串。format()方法有两种重载形式 1，format（String format.Object...args）  该方法使用指定的格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用本地默认的语言环境： str.format(String format,Object...args) format:格式字符串        args:格式字符串中由格式说明符引用的参数。 2，format（Local l,String format,Object...args）  该方法使用指定的语言环境，格式字符串和参数返回一个格式字符串，格式化后的新字符串使用其指定的语言环境： str.format(Local l,String format,Object...args)

日期和时间字符串格式化

日期格式化 Date date = new Date(); String s = String.format("%te",date);

例题10.13 import java.util.Date; public class Eval {    public static void main(String[] args) {   // TODO 自动生成的方法存根   Date date = new Date();//创建Date对象date   String year = String.format("%tY", date);//将date进行格式化   String month = String.format("%tB", date);   String day = String.format("%td", date);   System.out.println("今年是："+year + "年");//输出信息   System.out.println("现在是："+month);   System.out.println("今天是："+day + "号");     }   }

时间格式化        使用format0方法不仅可以完成日期的格式化，也可以实现时间的格式化。时间的格式化转换符要比日期的格式化转换符更多、更精确，它可以将时间格式化为时、分、秒、毫秒等格式化时间的转换符

例题10.14 import java.util.Date; public class GetDate {  public static void main(String[] args) {   // TODO 自动生成的方法存根   Date date =new Date();//创建Date对象date     String hour = String.format("%tH", date);//将date进行格式化     String minute= String.format("%tM", date);     String second = String.format("%tS", date);     System.out.println("现在是："+hour+"时"+minute +"分"+second + "秒");//输出信息  }   }

格式化常见的日期时间组合  格式化日期与时间组合的转换符定义了各种日期时间组合的格式，其中最常用的如下：

例题10.15 import java.util.Date; public class DateAndTime {    public static void main(String[] args) {   // TODO 自动生成的方法存根   Date date = new Date();//创建Date对象date   String time = String.format("%tc", date);//将date格式化   String form = String.format("%tF", date);   System.out.println("全部的时间信息是："+ time);//将格式化后的日期时间输出   System.out.println("年-月-日格式"+ form);  }   }

常规类型格式化

例题10.16 public class General {    public static void main(String[] args) {   // TODO 自动生成的方法存根 String str=String.format("%d",400/2);//将结果以十进制格式显示 String str2=String.format("%b",3>5);//将结果以boolean型显示 String str3=String.format("%x",200);//将结果以十六进制显示z System.out.println("400的一半是："+str);//输出格式字符串 System.out.println("3>5正确吗："+str2); System.out.println("200的十六进制数是："+str3);  }  }

使用正则表达式

正则表达式通常被用于判断语句中，用来检查某一字符串是否满足某一格式。正则表达式是含一些具有特殊意义字符的字符串，这些特殊字符称为正则表达式的元字符。例如，“\d”表示数字9中的任何一个，“d”就是元字符。 在正则表达式中，可以使用方括号括起若千个字符来表示一个元字符，该元字符可代表方括号中的任何一个字符。例如，reg =“[abc]4”，这样字符串 a4、b4、4 都是和正则表达式匹配的字符串。方括号元字符还可以为其他格式。如:   [456]:代表4、5、6之外的任何字符  [a-r]: 代表a~r中的任何一个字母。  [a-zA-Z]:可表示任意一个英文字母。  [a-e[g-z]]:代表 a~e 或 g~z 中的任何一个字母(并运算)。 [a-o&&[def]]:代表字母 d、e、f (交运算)。 [a-d&&[^bc]]: 代表字母 a、d(差运算)。 在正则表达式中允许使用限定修饰符来限定元字符出现的次数。例如，“A*”代表 A 可在字符串中出现 0次或多次。

例题10.17 public class Judge {    public static void main(String[] args) {   // TODO 自动生成的方法存根   String regex = "\\w+@\\w+(\\.\\w{2,3})*\\.\\w{2,3}";   //定义要匹配e-mail地址的正则表达式   String str1 = "aaa@";//定义要进行验证的字符串   String str2 = "aaaaa";   String str3 = "1111@111ffyu.dfg.com";   if(str1.matches(regex)) {//判断字符串变量的hi发与正则表达式匹配    System.out.println(str1+"是一个合法的E—mail地址格式");   }   if(str2.matches(regex)) {    System.out.println(str2+"是一个合法的E—mail地址格式");   }   if(str3.matches(regex)) {    System.out.println(str3+"是一个合法的E—mail地址格式");   }  }   }

字符串生成器

创建成功的字符串对象，其长度是固定的，内容不能被改变和编译。虽然使用“+”可以达到附加新字符或字符串的目的，但“+”会产生一个新的 String 实例，会在内存中创建新的字符串对象。如果重复地对字符串进行修改，将极大地增加系统开销。而JDK 新增了可变的字符序列 StringBuilder类,大大提高了频繁增加字符串的效率。

append()方法 该方法用于向字符串生成器中追加内容。通过该方法的多个重载形式，可实现接受任何类型的费据，如int、boolean、char、String、double 或者另一个字符串生成器等。语法如下: append(content) 其中，content表示要追加到字符串生成器中的内容，可以是任何类型的数据或者其他对象

insert(int offset, arg)方法 该方法用于向字符串生成器中的指定位置插入数据内容。通过该方法的不同重载形式，可实现向字符串生成器中插入 int、float、char 和 boolean 等基本数据类型的数据或其他对象。语法如下: insert(int offset arg) ofset: 字符串生成器的位置。该参数必须大于等于0，且小于等于此序列的长度。 arg:将插入至字符串生成器的位置。该参数可以是任何数据类型的数据或其他对象。向字符串生成器中指定的位置添加字符，代码如下: StringBuilder bf= new StringBuilder("hello")；//创建字符生成器 bf.insert(5，"world");//添加至字符生成器的位置及内容 System.out.println(bf.toString());//此时输出信息为hello word

.delete(int start , int end)方法（前删后不删）  移除此序列的子字符串中的字符。该子字符串从指定的 start 处开始，一直到索引 end-1处的字符。如果不存在这种字符，则一直到序列尾部。如果 stat 等于 end，则不发生任何更改。语法如下: delete(int start , int end) start:将要删除的字符串的起点位置  end:将要删除的字符串的终点位置 删除指定位置的子字符串，代码如下: StringBuilder bf = new StringBuilder("StringBuilder");//创建字符串生成器 bf.delete(5,10);//删除的子字符串 System.out.preintln(bf.toString());//此时输出的信息为Strinder

常用类库

包装类

Integer类

在对象中包装了一个基本数据类型int的值，该类的对象包含一个int类型的字段 该类方法还提供了多个方法，能够在int和String类型之间互相转换

Integer类的常用方法   package lit;   public class IntegerDemo {    public static void main(String[] args) {   int num=Integer.parseInt("456");//将字符串转换为int类型   Integer iNum=Integer.valueOf("456");//创建Integer对象   System.out.println("int 数据与Integer对象的比较："+iNum.equals(num));   String str2=Integer.toBinaryString(num);//获取二进制表达   String str3=Integer.toHexString(num);//获取十六进制表达   String str4=Integer.toOctalString(num);//获取八进制表达   String str5=Integer.toString(num,15);//获取十五进制表达   System.out.println("456的二进制表示为："+str2);   System.out.println("456的十六进制表示为："+str3);   System.out.println("456的八进制表示为："+str4);   System.out.println("456的十五进制表示为："+str5);  }   }

除了方法Integer类还提供了以下4个常量

查看Integer类的常量值   package lit;   public class GetCon {    public static void main(String[] args) {   int maxint=Integer.MAX_VALUE;//获取常量值   int minint=Integer.MIN_VALUE;   int intsize=Integer.SIZE;   //输出   System.out.println("int类型可取的最大值是："+maxint);   System.out.println("int类型可取的最小值是："+minint);   System.out.println("int类型的二进制位数是："+intsize);    }   }

Double类

double类和float类是对double、float基本类型的封装，它们都是 Number类的子类， 所以常用方法基本相同 。 Double类在对象中包装一个基本类型为double的值，每个Double类的对象都包含一个double类型的字段，此外，该类还提供多个方法，可以将double类型转换为为String类型，将String类型转换为double类型，也提供了其他一些处理double类型时有用的常量和方法。                                                              Double 类还提供了以下常量:  MAX_EXPONENT:返回 int 值，表示有限 double 变量可能具有的最大指数 MIN_EXPONENT:返回 int值，表示标准化 double 变量可能具有的最小指数 NEGATIVE_INFINITY: 返回 double 值，表示保存 double 类型的负无穷大值的常量  POSITIVE_INFINITY: 返回 double 值，表示保存 double 类型的正无穷大值的常量

Double类的常用方法 package lit;   public class DoubleDemo {    public static void main(String[] args) {   Double dNum=Double.valueOf("3.14");   System.out.println("3.14是否为非数字值："+Double.isNaN(dNum.doubleValue()));   System.out.println("3.14转换为int值值："+dNum.intValue());//转换为int型   //判断大小   System.out.println("值为3.14的Double对象与3.14的比较结果："+dNum.equals(3.14));   //转换为十六进制   System.out.println("3.14的十六进制表示为值："+Double.toHexString(dNum));    }   }

Boolean类

Boolean类将基本类型为 boolean 的值包装在一个对象中。一个 Boolean 类型的对象只包含一个类型为 boolean 的字段。 此类还为 boolean 类型和 Sring 类型的相互转换提供了许多方法，并提供了处理 boolean 类型时非 常有用的其他一些常量和方法。 Boolean类还提供了以下常量:   TRUE:对应基值true的Boolean对象 FALSE：对应基值false的Boolean对象 TYPE：基值booleand的Class对象

Boolean 类的常用方法 package lit;   public class BooleanDemo {    public static void main(String[] args) {   //创建Boolean对象   Boolean b1=Boolean.valueOf("true");   Boolean b2=Boolean.valueOf("ok");   System.out.println("b1:"+b1.booleanValue());   System.out.println("b2:"+b2.booleanValue());   //只要不是true就全是false  }   }

Character类

Character 类在对象中包装一个基本类型为 char 的值,该类提供了多种方法，以确定字符的类别小写字母、数字等)，并可以很方便地将字符从大写转换成小写，反之亦然。 Character类还提供了以下常量:    CONNECTOR_PUNCTUATION:返回byte型值，表示 Unicode 规范中的常规类别“Pc” UNASSIGNED:返回 byte 型值，表示 Unicode 规范中的常规类别“Cn” TITLECASE_LETTER:返回 byte型值，表示Unicode 规范中的常规类别“Lt”。

Character类的常用方法   package lit;   public class UpperOrLower {    public static void main(String[] args) {   Character mychar1=Character.valueOf('A');   Character mychar2=Character.valueOf('a');   if(Character.isUpperCase(mychar1)) {//判断是否为大小写    System.out.println(mychar1+"是大写字母");    //转换为小写输出    System.out.println("转换为小写字母的结果："+Character.toLowerCase(mychar1));    }   if(Character.isLowerCase(mychar2)) {    System.out.println(mychar2+"是小写字母");    //转换为大写输出    System.out.println("转换为大写字母的结果："+Character.toUpperCase(mychar1));    }       }   }

Number类

对于数值型的包装类，它们有一个共同的父类一Numbr类，该类是一个抽象类，它是 Byte、Integer、Short、 Long、Flat 和 Double 类的父类，其子类必须提供将表示的数值转换为 byte、int、short、long、float 和 double 的方法。 在 Number 类的所有子类中都包含以上这儿种方法。

数字处理

Java 语言中，提供了一个执行数学基本运算的 Math 类，该类包括常用的数学运算方法，如三角函数方法等一些常用数学函数方法。除此之外还提供了一些常用的数学常量。 在实际开发中，随机数的使用是很普遍的，所以要掌握生成随机数的操作。 在 Java 中主要提供了两种生成随机数的方式 调用 Math 类的random()方法生成随机数 调用 Random类生成各种数据类型的随机数 Java中，还提供了大数字的操作类，即 java.math,BigInteger 类与javamathBigDecimal类这两个类 用于高精度计算，其中 BigInteger 类是针对大整数的处理类，而 BigDecimal 类则是针对大小数的

数字格式化

数字格式化在解决实际问题时应用非常普遍，如表示超市的商品价格，需要保留两位小数。 主要针对的是浮点型数据，包括double和float数据， 使用Java.text.DecimalFormat java中没有数据格式化的数据遵行以下原则 如果数据绝对值大于0.001并且小于10000000，使以常规小数形式表示 如果数据绝对值小于0.001或者大于10000000，使用科学记数法表示 DecimalFormat类是NumberFormat 的一个子类， 用于格式化十进制数字。 可以在实例化 DecimalFormat 对象时传递数字格式，也可以通过 DecimalFormat类中的applyPattern()方法来实现数字格式化。 SimgleFormat()方法是在实例化 Decimalformat 对象时设置数字格式化模板  UseApplyPatternMethodPormal0)方法是在实例化 DecimalFormat 对象后调用spplype方法设置数宇格式化模板。 在 DecimalFormat 类中，除了可通过格式化模板来格式化数字，还可以使用一些特殊方注对数行格式化设置。例如： myFormat2.setGroupingSize(3);//设置几个数进行初始化 myFormat2.setGroupingUsed(true);//setGroupingUsed的开关 String my2=myFormat2.format(7857478);//传入要格式化的数

DecimalFormat类的常用方法 package lit; import java.text.DecimalFormat;//导入类 public class DecimalFormatSimpleDemo {  //使用实例化对象设置格式化模式  static public void SimgleFormat(String pattern,double value) {   DecimalFormat myFormat=new DecimalFormat(pattern);//实例化DecimalFormat对象   String output =myFormat.format(value);//将数字格式化   System.out.println(value+""+pattern+""+output); }  //使用applyPattern()方法对数字进行格式化 static public void UseApplyPatternMethodFormat(String  pattern,double value) {  DecimalFormat myFormat=new DecimalFormat();//实例化DecimalFormat对象  myFormat.applyPattern(pattern);//调用applyPattern()方法设置格式化模板  System.out.println(value+""+pattern+""+myFormat.format(value));   } public static void main(String[] args) {  SimgleFormat("###,###.###",123456.789);//调用静态StringFormat()方法  SimgleFormat("00000000.###kg",123456.789);//加上单位    SimgleFormat("000000.000",123.78);    UseApplyPatternMethodFormat("#.###%",0.789);//将数字转换为百分比形式  UseApplyPatternMethodFormat("###.##",123456.789);//将小数点后格式化为两位  UseApplyPatternMethodFormat("0.00\u2030",0.789);//将数字转换为千分数形式       }   }

Math类

Math类提供了众多数学函数方法，主要包括三角函数方法，指数函数方法，取整函数方法，取最大值、最小值，以及平均值函数方法。这些方法都被定义为 static 形式，所以在程序中应用比较简便，使用方法如下： Math.函数方法  三角函数方法  public static double sin(double   a): 返回角的三角正弦。 public static double cos(double    a):返回角的三角余弦 public static double tan(double     a): 返回角的三角正切。 public static double asin(double    a):返回一个值的反正弦 public static double acos(double   a): 返回一个值的反余弦 public static double atan(double     a): 返回一个值的反正切。 public static double toRadians(double   angdeg): 将角度转换为弧度 public static double toDegrees(double    angrad): 将弧度转换为角度。 以上每个方法的参数和返回值都是 double型的。将这些方法的参数的值设置为 double 型是有一定道理的，参数以弧度代替角度实现，角度与弧度的转换通常是不精确的。

在Java代码中进行三角函数运算 package lit;   public class TrigonometricFunction {    public static void main(String[] args) {      System.out.println("90度的正弦值："+Math.sin(Math.PI/2));//取90°的正弦   System.out.println("0度的余弦值："+Math.cos(0));//取0°的余弦   System.out.println("60度的正切值："+Math.tan(Math.PI/3));//取60°的正切   //取2的平方根与2的商的反正弦值   System.out.println("2的平方根与2的商的反正弦值："+Math.asin(Math.sqrt(2)/2));   //2的平方根与2的商的反余弦值   System.out.println("2的平方根与2的商的反余弦值："+Math.acos(Math.sqrt(2)/2));   System.out.println("1的反正切值："+Math.atan(1));//取1的反正切   System.out.println("120度的弧度值："+Math.toRadians(120.0));//取120°的弧度值   System.out.println("Π/2的角度值:"+Math.toDegrees(Math.PI/2));//取Π/2的角度       }   }

指数函数方法  pbhe static double exp(double a): 用于获取e的a次方，即取 publie static double log(double a): 用于取自然对数，即取lna的值。 public staric double logl0(double a):用于取底数为10的a的对数 public static double sqrt(double a):用于取a的平方根，其中a的值不能为负值 public static double cbrt(double a):用于取a的立方根。 public static double pow(double a，double b):用于取a的b次方。

在Java中使用指数函数进行运算 package lit;   public class ExponentFunction {    public static void main(String[] args) {   System.out.println("e的平方值："+Math.exp(2));//取e的2次方   System.out.println("以e为底2的对数值："+Math.log(2));//取以e为底2对数   System.out.println("以10为底2的对数值："+Math.log10(2));//取以10为底2的对数值   System.out.println("4的平方根值："+Math.sqrt(4));//取平方根   System.out.println("8的立方值："+Math.cbrt(8));//取8的立方   System.out.println("2的2次方值："+Math.pow(2, 2));//取2的2次方       }   }

取整函数方法  public static double ceil(double a): 返回大于等于参数的最小整数。  public static double floor(double a): 返回小于等于参数的最大整数。 public  static double rint(double a): 返回与参数最接近的整数，如果同样接近，取偶数。 public static int round(float a): 将参数加上0.5 后返回与参数最近的整数。public static long round(double a): 将参数加上0.5后返回与参数最近的整数，然后强制转换为长整型。

各场景下取整函数的运算结果   package lit;   public class IntFunction {    public static void main(String[] args) {    System.out.println("使用ceil()方法取整："+Math.ceil(5.2));//返回一个大于等于参数的整数    System.out.println("使用floor()方法取整："+Math.floor(2.5));//返回一个小于等于参数的整数    System.out.println("使用rint()方法取整："+Math.rint(2.7));//返回与参数最接近的整数    System.out.println("使用rint()方法取整："+Math.rint(2.5));//返回与参数最接近的整数  //将参数加上0.5后返回最接近的整数    System.out.println("使用round()方法取整："+Math.round(3.4f));  //将参数加上0.5后返回最接近的整数，并将结果强制转换为长整型    System.out.println("使用round()方法取整："+Math.round(2.5));  }   }

取最大值、最小值、绝对值函数方法  publie static   double max(double a,double b）: 取a与b之间的最大值 publie static   int  min(int a,int b): 取a 与b之间的最小值，参数为整型 publie static  long min(long a,long b): 取 a与b之间的最小值，参数为长整型 publie static flat min(float a,float b): 取a 与b之间的最小值，参数为单精度浮点型 publie static  double min(double a.double b): 取a 与b之间的最小值，参数为双精度浮点型 publie static int   abs(int a): 返回整型参数的绝对值。 public static long abs(long a): 返回长整型参数的绝对值。 public static float abs(floata): 返回单精度浮点型参数的绝对值。 publie static double abs(double a):: 返回双精度浮点型参数的绝对值。

取最大值、最小值、绝对值的方法 package lit;   public class AnyFunction {    public static void main(String[] args) {   System.out.println("4和8的较大者："+Math.max(4, 8));//取两数的最大值   System.out.println("4.4和4的小者："+Math.min(4.4, 4));//取两数的最小值   System.out.println("-的绝对值："+Math.abs(-7));//取绝对值    }   }

Random类

Random 类是JDK 中的随机数生成器类 可以通过实例化一个 Random 对象创建一个随机数生成器，语法如下： Random r=new Random(); 因为每时每刻的时间不可能相同，所以产生的随机数不同。但是如果运行速度太快，也会产生两 个运行结果相同的随机数。 可以在实例化 Random 类对象时，设置随机数生成器的种子，语法如下: Random r = new Random(seedValue);

Random的常用方法  public   int   nextInt():返回一个随机整数。 public    int nextInt(int n): 返回大于等于0 且小于n 的随机整数 public   long nextLong(): 返回一个随机长整型值。 public   boolean nextBoolean(): 返回一个随机布尔型值。 public   float nextFloat(): 返回一个随机单精度浮点型值。 public  double nextDouble(): 返回一个随机双精度浮点型值。 public  double nextGaussian(): 返回一个概率密度为高斯分布的双精度浮点型值。

获取不同取值范围、不同类型的随机数 package lit;   import java.util.Random;   public class RandomDemo {    public static void main(String[] args) {   Random r=new Random();//实例化一个Random对象   //随机产生一个整数   System.out.println("随机产生一个整数："+r.nextInt());   //随机产生一个大于等于0小于10的整数   System.out.println("随机产生一个大于等于0小于10的整数："+r.nextInt(10));   //随机产生一个布尔型的值   System.out.println("随机产生一个布尔型的值："+r.nextBoolean());   //随机产生一个双精度浮点数的值   System.out.println("随机产生一个双精度浮点数的值："+r.nextDouble());   //随机产生一个单精度浮点数的值   System.out.println("随机产生一个单精度浮点数的值："+r.nextFloat());   //随机产生一个概率密度为高斯分布的双精度浮点型值   System.out.println("随机产生一个概率密度为高斯分布的双精度浮点型值："+r.nextGaussian());          }   }

Biginteger类

Integer 类是 int 的包装类int 的最大值为2的31次方减1，如果要计算更大的数字，使用 Integer 类就无法 实现了 所以 Java 中提供了BigInteger 类来处理更大的数字使用 BigInteger 类，可以实例化一BigInteger 对象，并自动调用相应的构造函数 例如，将2转换为 Biglnteger 类型，可以使用以下语句进行初始化操作: BigInteger twolnstance = new Biginteger("2")

BigInteger类中常用的几种运算方法:  public BigInteger add(BigInteger val): 做加法运算。 public BigInteger subtract(BigInteger val): 做减法运算 public BigInteger multiply(BigInteger val): 做乘法运算 public BigInteger divide(BigInteger val): 做除法运算。 public BigInteger remainder(BigInteger val): 做取余操作 public BigIntegerl [ ]divideAndRemainder(Biglnteger val): 用数组返回余数和商，结果数组中第一 个值为商，第二个值为余数。 public BigInteger pow(int exponent): 进行取参数的exponent 次方操作。 public BigInteger negate(): 取相反数。 public BigInteger shiftLef(int  n): 将数字左移n位，如果n 为负数，做右移操作 public BigInteger shiftRight(int n): 将数字右移n 位，如果n为负数，做左移操作 public BigInteger and(BigInteger val): 做与操作。 public BigInteger or(BigInteger val): 做或操作。 public int compareTo(BigInteger val): 做数字比较操作。 public boolean equals(Object x): 当参数x是 BigInteger 类型的数字并且数值与对象实例的数值相等时，返回 true。 public BigInteger min(BigInteger val): 返回较小的数值。 public BigInteger max(BigInteger val): 返回较大的数值。

使用 BigInteger 类进行数学运算 package lit;   import java.math.BigInteger;   public class BigIntgerDemo {    public static void main(String[] args) {   BigInteger b1=new BigInteger("987654321987654321");//第1个大数字   BigInteger b2=new BigInteger("123456789123456789");//第2个大数字   System.out.println("加法操作："+b1.add(b2));//加法运算   System.out.println("减法操作："+b1.subtract(b2));//减法运算   System.out.println("乘法操作："+b1.multiply(b2));//乘法运算   System.out.println("除法操作："+b1.divide(b2));//除法运算   System.out.println("取商："+b1.divideAndRemainder(b2)[0]);//取商   System.out.println("取余数："+b1.divideAndRemainder(b2)[1]);//取余数   System.out.println("做2次方操作："+b1.pow(2));//取2次方运算   System.out.println("取相反数操作："+b1.negate());//相反数运算       }   }

divideAndRemainder()方法做除法操作，以数组的形式返回,。第一个值为做除法的商，第二个值为做除法的余数

BigDecimal类

BigDecimal类和 Biglnteger 类都能实现大数字的运算， 不同的是BigDecimal类加入了小数的概念，一般的float和double 型数据只可以用来做科学计算工 程计算，但由于在商业计算中要求数字精度比较高，所以要用到BigDecimal类。 BigDecimal类支持任何精度的定点数，可以用它来精确计算低值。 BigDecimal类中的常用构造方法

BieDecimal 类型的数字可以用来做超大的浮点数的运算，如加、减、乘、除等，但是在所有的运 算中除法是最复杂的，因为在除不尽的情况下商小数点后的末位的处理是需要考虑的

divide()方法的多种处理模式

system类

控制台输出字符

System 类是 JDK 中提供的系统类，该类是用 final 修饰的，所以不允许被继。 System 类提供的方法全部都是静态的                                                                                                                                                                                控制台输出字符 System 类提供了标准输入in、标准输出out和错误输出流err 不会自动换行的 print()方法 System.out.print(); 可以自动换行的 println()方法  println()方法在 print后面加上了“In”后缀 (就是 line 的简写) System.out.println(); Java 输出换行的方法有以下两种: System.out.print("\n");                //利用换行符n 实现换行 System.out.println();                  //空参数即可实现换行

计时

Sywem.curemTimeMillis()方法可以获取现在的毫秒数。 虽然 Date 日期也有类似的方法，但代码会比 Systcm 类多， 所以 System.currentTimeMillis()方法是为获取当前毫秒最常用的方法。 该方法的返回值精确到毫秒，所以可以利用该方法来记录程序的运行时间。

查看执行一万次字符串拼接所消耗的时间 package lit;   public class SystemTimeDemo {    public static void main(String[] args) {   long start=System.currentTimeMillis();//获取程序开始的时间   String str=null;   for(int i=0;i<10000;i++) {//循环次数    str+=i;       }   long end=System.currentTimeMillis();//获取程序结束时间   System.out.println("循环用时："+(end-start)+"毫秒");//输出  }   }

scanner类

Java 从控制台中读出用户输入的值，用到的是一个叫 Scanner 的类来实现的。 Scanner 英文直译就是扫描仪，它的用途就是数字化信息流转为人类可识别的文字。 System.out 就表示向控制台输出 System.in 就表示从控制台输入 让 Sanner 扫描 System.in 就可以获取用户输入的值了使用 Scanner 类首先要引入该类，语法如下： import java.util.Scanner；

Scanner 类提供的几种常用的方法

nextLine()方法扫描的内容是从第一个字符开始到换行符为止 而 next()、nextInt()等方法扫描的内容是从第一个字符开始到这段完整内容结束。 使用 Scanner 类扫描控制台的代码如下: Scanner sc = new Scanner(System.in); System.in 表示控制台输入流，

猜数字游戏 package lit;   import java.util.Random; import java.util.Scanner;   public class ScannerDemo {  public static void main(String[] args) {   Random r=new Random();//随机数对象   int num=r.nextInt(100);//1~99   int input=0;//记录用户输入的值   Scanner sc=new Scanner(System.in);//打开扫描器   while(true) {    System.out.println("猜一猜随机数是多少?");    input=sc.nextInt();    if(input>num) {     System.out.println("你输入的数字大了");    }else if(input<num) {     System.out.println("你输入的数字小了");    }else if (input==num) {//如果等于随机数，结束循环     break;         }else {     System.out.println("你的输入有误！");    }   }   System.out.println("恭喜你答对了！");   sc.close();//关闭扫描器，不然很占内存  }   }

日期时间类

Date类

Date 类用于表示日期时间，，使用该类表示时间需要使用其构造方法创建对象

创建 Date 对象时使用的是 long 型整数，而不是 double 型，因为 double 类型可能会损失精度

获取当前的日期和时间 package lit;   import java.util.Date;   public class DateDemo {    public static void main(String[] args) {   Date date=new Date();//创建现在的日期   long value=date.getTime();//获取毫秒数   System.out.println("日期："+date);   System.out.println("到现在所经历的毫秒数为："+value);  }   }

日期时间格式化

日期时间格式化 DateFormat 类是日期时间格式化子类的抽象类，可以按照指定的格式对日期或时间进行格式化 DateFormat 类提供了很多类方法，以获得基于默认或给定语言环境和多种格式化风格的默认日期 时间Formatter，格式化风格主要包括 SHORT、MEDIUM、LONG 和FULL4种: SHORT:完全为数字，如 12.13.2或3:30pm。 MEDIUM:较长，如 Jan 12,1952。 LONG:更长，如January 12,1952 或3:30:32pm。 FULL:完全指定，如 Tuesday、April 12、1952AD 或3:30:42pm PST。 另外，使用 DateFormat 类还可以自定义日期时间的格式。要格式化一个当前语言环境下的日期,首 先需要创建 DateFormat 类的一个对象，由于它是抽象类，因此可以使用其静态方 getDateInstance()进行创建，语法如下: DateFormat df = DateFormat.getDatelnstance(); 使用 getDateInstance()方法获取的是所在国家或地区的标准日期格式。另外，DateFormat 类还提 供了一些其他静态方法。例如，使用 getTimeInstance()方法可获取所在国家或地区的时间格式，

使用getDateTimeInstance()方法可获取日期和时间格式。

例如，将当前日期按照DateFormat类默认格式输出: DateFormat df = DateFormat.getlnstance(); System.out.println(df.format(new Date())); 结果： 2021/2/19上午9:59  输出长类型格式的当前时间: DateFormat df = DateFormat.getTimelnstance(DateFormat.LONG); System.out.println(df.format(new Date())); 结果：  CST 上午10:00:33 输出长类型格式的当前日期: DateFormat df = DateFormat.getDatelnstance(DateFormat.LONG); System.out.println(df.format(new Date())); 结果：  2021年2月19日 输出长类型格式的当前日期和时间: DateFormat df = DateFormatgetDate Timelnstance(DateFormat.LONG,DateFormat.LONG); System.out.println(df.format(new Date())); 结果： 2021年2月19日CST 上午10:01:12

SimpleDateFormat的格式化字符

Calendar类

Calendar 类提供的常用方法

add()方法和 roll()方法都用来为给定的日历字段添加或减去指定的时间量,它们的主要区别在于:使用 add()方法时会影响大的字段，像数学里加法的进位或错位，而使用 roll()方法设置的日期字段只是进行增加或减少，不会改变更大的字段。 package lit;   import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date;   public class CountDown {    public static void main(String[] args) {   System.out.println("——————————————中华人民共和国成立100周年倒计时——————————");   Date date=new Date();//当前时间   //创建SimpleDateFormat指定目标格式   SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyy年MM月dd日");   //调用format方法，格式化时间，转换为指定格式   String today=simpleDateFormat.format(date);   //输出当前时间   System.out.println("今天是"+today);   //将当前时间转换为毫秒数   long time1=date.getTime();   //使用默认时区和语言环境获得一个日历   Calendar calendar=Calendar.getInstance();   //设置日历calendar中的年月日，因为月份是从0开始计算的，所以这里   calendar.set(2049,10-1,1);   //计算1970年1月1日至2049年10月1日所经过的毫秒数   long time2=calendar.getTimeInMillis();   //计算差值   long day=(time2-time1)/(1000*60*60*24);   //输出   System.out.println("距离2049年10月1日还有"+day+"天！");  }   }

最后对 Calendar 类的使用做出几点总结:  c.set(CalendarDAY_OF_MONTH,0)获取的是上个月的最后一天，所以调用前需要将月份往后加一个月。  Calendar.MONTH的第一个月是使用0记录的，所以在获得月份数字后要加1。年和日是从1开始记录的，不需要加 1。 Calendar.DAY OF WEEK 的第一天是周日，周一是第二天，周六是最后一天

Runtime类

Runtime 类是 JDK 供的运行时类，该类为 Java程序提供了与当前运行环境相连接的一个通道，Runtime 类不能使用 new 关键字创建实例，只能通过 Runtime. getRuntime()方法获取实例。 Runtime 类的常用方法 public static Runtime getRuntime()  普通方法  用于取得Runtime类的实例 public long freeMemory()  普通方法 用于返回Java虚拟机中的空闲内存 public long maxMemory() 返回JVM的最大内存量 public void gc() 运行垃圾回收器。释放空间。 public Process exec(String command) throws IOException 执行本机命令

执行本地命令

本地命令指的是操作系统的命令。例如，在 Linux 系统下就表示 shell 命令，在 Windows 系统下 表示 cmd 命令。 Runtime 类提供 exec()方法让 Java 代码可以执行系统的命令，exec()方法有很多重载的形式，例如: Process exec(String command) Process exec(Stringl cmdarray) command:要执行的系统命令，字符串类型。  cmdarray:要执行的命令和相应的命令参数，字符串数组类型。  其实这两个重载方式很类似，如执行“javac hello.java”这行命令，使用第一种重载方式的代码如下  Runtime.getRuntime().exec("javac hello.java"); 使用第二种重载方式的代码如下: String command] =  {"javac", "hello,java" }; Runtime.getRuntime().exec(command); Process类的常用方法  p.start():启动进程，并调用该子进程中的p.run() p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法 p.terminate():强制终止进程p，不会进行任何清理操作 p.is_alive():如果p仍然运行，返回回True。用来判断进程是否还在运行 p.join([timeout]):主进程等待p终止，timeout是可选的超时时间 Process类常用的属性： p.name：当前进程实例别名，默认为Proce-N，N为从1开始递增的证书 p.pid:当前进程实例的PID值

package lit;   import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; public class RuntimeExecDemo {    public static void main(String[] args) {   Runtime r=Runtime.getRuntime();//获取本地Runtime对象   try {    Process p=r.exec("help");//执行help命令，获取进程对象    InputStream is=p.getInputStream();//获取进程的字节输入流    BufferedReader br=new BufferedReader(new InputStreamReader(is));    String str=null;//创建空字符    while((str=br.readLine())!=null) {//如果字符流中可以获取非空内容     System.out.println(str);//打印    }      }catch(IOException e) {    e.printStackTrace();   }    } }

查看内存

Runtime类可以通过 freeMemory()方法查看当前Java 虚拟机可用内存的剩余量。如果程序能够实时监控内存剩余量，就可以尽量控制程序对内存的占用，从而避免出现“内存溢出”的情况。同样，也可以用来对测试程序性能，检验程序算法是否导致内存紧张。

监控虚拟机内存的使用情况 package lit;   public class MemoryDemo {    public static void main(String[] args) {       Runtime r=Runtime.getRuntime();//获取本地Runtime对象     Integer ints[]=new Integer[10000];//创建长度为10000的整型数组     long before=r.freeMemory();//获取当前空闲内存数     System.out.println("赋值前空闲内存字节数："+before);     for(int i=0,length=ints.length;i<length;i++) {//循环为整型数组赋值      ints[i]=i;//赋值     }     long after=r.freeMemory();//获取当前空闲内存数     System.out.println("赋值后空闲内存字节数："+after);     System.out.println("数组用掉的内存字节数："+after);//输出数组用掉的内存量     }      }