大家好，我是讯享网，很高兴认识大家。

一. java基础语法

类：类是一个模版，描述一类对象的行为和状态

对象：对象是类的一个实例，有状态和行为

方法：是对象的行为

实例变量：对象的状态，每个对象都有独特的实例变量（状态）

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

讯享网

其中： public(访问修饰符) static(关键字) void main

命名方式：

类名：类名的首字母大写，并且每个单词的首字母大写

方法名：以小写字母开头，后面的每个单词大写

源文件名：后缀是.java，与类名相同

Java标识符

• 标识符以大小写字母、$、_开始

Java修饰符

java使用修饰符来修饰类中的方法和属性，主要有两个修饰符：

• 访问控制修饰符：default,pulic,protected,private
• 非访问控制修饰符：final,abstract,static,synchronized

Java变量

• 局部变量
• 类变量（静态变量）
• 成员变量（非静态变量）

Java数组

数组是存储在堆上的对象，可以保存多个同类型的变量

java枚举

美剧限制变量只能是预先设定好的值

继承

如果想要创建一个类，而且存在一个类具有该类所需要的属性和方法，则可以继承类，可以重用已存在类的方法和属性，而不用重写这些代码，被继承的类称为超类，派生的类是子类

接口

接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类

二. java对象和类

类型变量：

• 局部变量：在方法、构造方法或者语句块中定义的变量是局部变量，变量声明和初始化都是在方法中，方法结束后会自动销毁
• 成员变量：定义在类中、方法体以外的变量；在创建对象时实例化，可以被类中的方法、构造方法和特定类的语句块访问
• 类变量：定义在类中、方法体以外的变量，但需要声明为static类型

构造方法：是一种特殊的方法，它是一个与类同名的方法，其功能主要是完成对象的初始化

​ 每个类都有构造方法，如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。在创建一个对象的时候，至少调用一个构造方法。构造方法需要与类同名，一个类可以有多个构造方法

创建对象：

对象是根据类创建的，使用关键字new来创建一个新的对象

• 声明：声明对象名称和对象类型
• 实例化：使用关键字new一个对象
• 初始化：使用new创建对象时，会调用构造方法初始化对象

访问实例变量和调用成员方法：

讯享网public class Punny { 
    String name; int age; String color; public Punny(){ 
   } public void setName(String name){ 
    this.name = name; } public String getName(){ 
    return this.name; } public static void main(String[] args){ 
    Punny punny = new Punny(); punny.setName("dog"); System.out.println("This dog's name is "+punny.getName()); } } 

源文件声明规则：

• 一个源文件只能有一个public类，但是可以有多个非public类
• 源文件的名称与public类的类名一致，如果没有public类，则可以是任意名字
• 如果一个类定义在某个包中，那么package语句应该在首行
• import语句应该放在package和类定义语句之间
• import 语句和 package 语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明

Java包：对类和接口进行分类

import 语句就是用来提供一个合理的路径，使得编译器可以找到某个类

import java.io.*; 

上述代码将载入 java_installation/java/io 路径下的所有类

三. Java基本数据类型

变量：申请内存来存储值，分配的内存空间只能存储该类数据

Java两大数据类型：

• 内置数据类型：提供了八种基本类型：int,short,long,byte,float,double,char,boolean

数据类型	位数	默认值	范围	备注
byte	8	0	-27~27-1 (-128~127)	可代替整数，节省空间
short	16	0	-215~215-1 (-32768~32767)	可代替整数，节省空间
int	32	0	-231~231-1	整形变量默认为int
long	64	0L	-263~263-1
float	32	0.0f		单精度,不能用来表示精确的值
double	64	0.0d		单精度,不能用来表示精确的值
boolean		false	false,true
char	16	‘u0000’	0～65535	可以储存任何字符

可以通过valuename.MIN_VALUE/MAX_VALUE获取每个数据类型的最大值最小值，eg：Integer.MIN_VALUE

• 引用数据类型：指向一个对象
  • 对象、数组都是引用数据类型
  • 所有饮用类型的默认值都是null
  • 一个引用变量可以用来引用任何与之兼容的类型

java常量：

使用final关键字来修饰常量，通常用大写字母表示常量

讯享网final double PI = 3.; 

• 字面量可以赋给任意内置类型的变量
• byte,int,long,short都可以用十进制、十六进制以及8进制的方式来表示

int decimal = 100; int octal = 0144 int hexa = 0x64 

自动类型转换

低级可以转换成高级类型，但高级类型转换成低级类型需要强制转换

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

• 不能对boolean类型进行类型转换
• 不能把对象类型转换成不相关类的对象
• 转换的过程中可能会导致溢出或者损失精度
• 浮点数到整数是舍弃小数位，而不是四舍五入
• 整数的默认类型是int，小数的默认类型是double

四. Java变量类型

• 类变量：独立于方法之外的变量，用static修饰
• 实例变量/成员变量：独立于方法之外的变量，用static修饰
• 局部变量：在类的方法中定义的变量

Java局部变量

• 声明在方法、构造方法或者语句块中
• 变量在所在的方法被创建时被执行；当执行完成后，变量被销毁
• 访问修饰符不能作用于局部变量
• 局部变量只在声明他的方法、构造方法和语句块中可见
• 在栈上分配
• 局部变量没有默认值，所以局部变量被声明后，需要经过初始化

Java实例变量

• 实例变量声明在一个类中，但在方法、构造方法和语句块之外
• 实例变量在一个对象被实例化了以后，就被确定
• 实例变量在对象创建时创建，在对象被销毁的时候销毁
• 实例变量一般是设成私有，所以实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
• 实例变量可以声明在使用前活着使用后
• 访问修饰符可以修饰实例变量
• 实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
• 实例变量同类中可以直接通过变量名访问，但在静态方法和其他类中，应该使用完全限定名：ObejectReference.VariableName

类变量（静态变量）

• 类变量属于类，所以无论一个类创建了多少个对象，类只拥有类变量的一份拷贝，所有对象操作同一个变量
• 静态变量存储在静态存储区中，经常被声明为常量，如果是final,static类型的变量，初始化之后不可以改变（一般大写）
• 静态变量在第一次被访问时创建，在程序结束时销毁
• 静态变量的值可以在声明的时候指定，也可以在构造方法中指定，静态变量还可以在静态语句块中初始化
• 静态变量可以通过：ClassName.VariableName的方式访问

讯享网import java.io.*: public class Employee{ 
    private static double salary; public static void main(String[] args){ 
    //在静态方法中初始化 salary = 10000; } } 

五. Java修饰符

修饰类用来定义类、方法、变量，通常放在语句的最前端

访问控制修饰符：控制访问权限

default：在同一包内类可见。注：接口里的变量都隐式声明为public static final,接口里的方法默认情况下的访问权限是public

private：在同一类内可见，但不可以作用于类/接口；目的是实现细节和保护类的数据

public：对所有类可见

protected：对同一包内的类和所有子类可见，但不可以作用于类/接口

• 子类于基类在同一包中：被声明为protected的变量、方法和构造器能被同一个包中的任何其他类访问
• 子类与基类不在同一个包中：在子类中，子类实例可以访问其从基类继承而来的protected方法，而不能访问基类实例的protected方法

访问控制和继承：

• 父类中声明为public的方法在子类中也必须为public
• 父类中声明为protected的方法在子类中要么声明为protected，要么声明为public，而不能声明为private
• 父类中声明为private的方法，不能被子类继承

非访问修饰符

static：可以用来修饰方法和变量

• 静态变量：static关键字用来声明独立于对象的静态变量，该变量只与类有关，每个类无论有多少个对象，之只有一份拷贝
• 静态方法：static关键字用来声明独立于对象的静态方法，所以钙方法中不能使用类的非静态方法

静态变量和静态方法可以使用类名.方法名/变量名访问到

final：

• 被final修饰的变量，一旦被赋值后，不能被重新赋值，所以该变量必须显式指定初始值；final修饰符通常和static修饰符一起来使用创建类常量
• 被final修饰的方法，可以被子类继承，但是不能被子类重写
• 被final修饰的类，不能被继承

abstract：用来修饰类和方法

抽象类不能用来实例化对象，抽象类的目的是提取出多个类的公共部分，这些类可以对抽象类进行扩充。所以abstract不能与final一起使用。

注：抽象类可以包含抽象方法和非抽象方法

• 抽象方法：不包括任何实现，该方法的具体实现由子类提供；不能被声明为final和static
• 任何继承抽象类的子类必须实现父类中的所有抽象方法。但抽象类可以不包含抽象方法

synchronized：

synchronized关键字声明的方法同一时间只能被一个线程访问

volatile：

volite修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。当成员变量发生变化时，会强制县城将变化后的值写回到共享内存中，所以不同的线程看到的是某个成员变量的同一个值

transient：

将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会被序列化

六. Java运算符

算术运算符

+,-,*,/,%,++,–

关系运算符

==,!=,>,<,>=,<= 返回的是true or false

位运算符

&,|,^,~,<<(*2),>>(/2),>>>(按位右移补零操作符)

逻辑运算符

&&, || ,! 返回的是true or false（会涉及到短路逻辑运算符）

赋值运算符

=,+=,-=,*=,/=,(%)=,<<=,>>=,&=,^=,!=

条件运算符

（三元运算符）

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

instanceof

判断一个对象是否是一个特定的类型（类类型或者接口类型）

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

Java运算符优先级

由高到低的顺序：

讯享网

七. Java循环结构

while循环、do…while循环、for循环，break，continue

增强for循环

for(声明语句 ： 表达式) { //代码 } 

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

八. 条件语句

if…else

九. switch case语句

语法

讯享网switch(expression){ 
    case value: //语句 break; case value: //语句 break; default: //语句 } 

• switch语句中的类型类型可以是:byte, short,int,char,string，但必须是字符串常量或者字面量
• case语句中的值的数据类型必须与变量的数据类型相同，可只能是常量或者字面常量
• 当遇到 break 语句时，switch 语句终止。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
• switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

Switch case执行时，一定会先进行匹配，匹配成功返回当前case的值，再根据是否有break是否继续输出，或者是跳出判断

十. Java Number & Math类

Number

内置数据类型byte, int,long,double等类型，都有对应的包装类，实际使用过程中，可以实例化为对象。

所有包装类(Integer,Short,Long,Float,Double,Byte)都是抽象类Number(java.lang.Number)的子类

注：编译器可以直接讲上述包装类装箱，而不需要实例化

Integer a = 5;//该种即可 Integer a = new Integer(5); 

Math

包含了各种数学运算的属性和方法，这些方法都被定义为static类型，可以直接调用

Number & Math 类方法

xxxValue()	将Number对象转换为xxx数据类型的值并返回
compareTo()	将Number对象与参数比较
equals()	判断number对象是否与参数相等
valueOf()	返回一个Number对象执行的内置数据类型
toString()	以字符串形式返回值
parseInt()	将字符串解析为int类型
abs()	返回参数的绝对值
ceil()	返回大于等于( >= )给定参数的的最小整数，类型为双精度浮点型
floor()	返回小于等于（<=）给定参数的最大整数
rint	返回与参数最接近的整数。返回类型为double
round()	它表示四舍五入，算法为 Math.floor(x+0.5)
min()	返回两个参数中的最小值
max()	返回两个参数中的最大值
exp()	返回自然数底数e的参数次方
log()	返回参数的自然数底数的对数值
pow()	返回第一个参数的第二个参数次方
sqrt()	求参数的算术平方根
sin(),cos(),tan()
asin(),acos(),atan()
atan2()	将笛卡尔坐标转换为极坐标，并返回极坐标的角度值
toDegress()	将参数转化为角度
toRadians()	将角度转换为弧度
Random	返回一个随机数

讯享网import com.sun.jdi.IntegerValue; public class numberTest { 
    public static void main(String[] args) { 
    //a.xxxValue() 方法用于将 Number 对象转换为 xxx 数据类型的值并返回 //无参数+特定类型的返回 Integer a = 5; System.out.println(a.byteValue()); System.out.println(a.doubleValue()); System.out.println(a.intValue()); //a.compareTo(b) 方法用于将 Number 对象与方法的参数进行比较 //可以比较Byte, Double, Integer, Float, Long 或 Short 类型 //相等返回0，小于等于-1，大于等于1 int b = 10; System.out.println(a.compareTo(b)); //a.quals(b) 方法用于判断 Number 对象与方法的参数进是否相等。 //返回true/false System.out.println(a.equals(b)); //Integer.valueOf(a) 方法用于返回给定参数的原生 Number 对象值 //参数可以是int,String,返回的是封装类型 Integer c = Integer.valueOf(a); Double d = Double.valueOf(b); //参数是string类型，返回的是Integer，转换成16进制 Integer e = Integer.valueOf("123",16); System.out.println(c); System.out.println(d); System.out.println(e); //Math.floor() 方法可对一个数进行下舍入，返回给定参数最大的整数，该整数小于或等给定的参数 //Math.ceil() 方法可对一个数进行上舍入，返回值大于或等于给定的参数 //Math.rint() 方法返回最接近参数的整数值 //Math.round() 四舍五入 double f = 1.6; System.out.println(Math.floor(f));//1 System.out.println(Math.ceil(f));//2 System.out.println(Math.rint(f));//2 System.out.println(Math.rint(f));//2 //其余的数学操作a=5,b=10 System.out.println(Math.max(a,b)); System.out.println(Math.min(a,b)); System.out.println(Math.abs(-1.6)); System.out.println(Math.exp(a)); System.out.println(Math.pow(a,b)); System.out.println(Math.sqrt(a)); } } 

十一. Java Character类

基本类型char可以用来对单个字符进行操作，但是在实际开发的过程中，经常会需要使用对象——包装类Character类。

构造对象

Character ch = new Character('a'); //将一个char类型的参数传递给需要一个Character类型参数的方法时，编译器会自动地将char类型参数转换为Charcter对象，这叫做装箱 Character ch = 'a'; 

转义序列

前面有反斜杠(\）,代表转义字符，有特殊含义

Character方法

方法	描述
isLetter()	是否为一个字母
isDigit()	是否为一个数字
isWhitespace()	是否为一个空白字符
isUpperCase()	是否为大写字母
isLowerCase()	是否为小写字母
toString()	返回字符的字符串形式

十二. Java String类

Java中的字符串属于对象。

创建字符串

讯享网String str1 = '123'; String str2 = new String('123'); 

//String创建的字符串存储在公共池中，但new创建的字符串对象在堆上 String s1 = "Runoob"; // String 直接创建 String s2 = "Runoob"; // String 直接创建 String s3 = s1; // 相同引用 String s4 = new String("Runoob"); // String 对象创建 String s5 = new String("Runoob"); // String 对象创建 

注：可以使用char数组、StringBuffer和StringBuilder来构造字符串。字符串不可以改变，

访问器方法

获取对象的信息的方法称为访问器方法

获取字符串包含的字符数length()方法

连接字符串

• string1.concat(string2);
• string1 + string2;

创建格式化字符串

下面两种用法等同

讯享网float floatVar = 1.0f; int intVar = 1; String fs = String.format("浮点数变量的值是："+ "%f, 整形变量的值是: %d",floatVar,intVar); System.out.println(fs); System.out.printf("浮点数变量的值是："+ "%f, 整型变量的值是: %d",floatVar,intVar); 

String方法（未完待续）

方法	描述
char charAt(int index)	返回指定索引处的char值
int comparTo(Object o)	与其他对象比较
int comparTo(String another)	按字典顺序比较
int comparToIgnoreCase(String another)	不考虑大小写
String concat(String str)	拼接字符串
boolean contentEquals(StringBuffer sb)	当字符串与指定的StringBuffer有相同顺序的字符时候返回真
static String copyValueOf(char[] data)	返回指定数组中表示该字符序列的 String
boolean endsWith(String suffix)	测试此字符串是否以指定的后缀结束。

subString(),concat(),replace()都是生成一个新的字符串

“对String对象的任何改变都不影响到原对象，相关的任何change操作都会生成新的对象”

十三. Java StringBuffer和StringBuilder类

由String创建的字符串不能更改，当对字符串进行修改时，需要使用StringBuffer和StringBuilder类，这两个类可以修改字符串，并且不产生新的对象

StringBuilder用法：速度快

public class StringBufferText { 
    public static void main(String[] args) { 
    //创建StringBuilder对象 StringBuilder stringBuilder = new StringBuilder(); //向StringBuilder中添加内容 stringBuilder.append("0"); System.out.println(stringBuilder);//0 //offset代表长度，而不是索引 stringBuilder.insert(3,"89"); System.out.println(stringBuilder);//0 //删除左闭又开 stringBuilder.delete(0,2); System.out.println(stringBuilder);// //字符串的反转形式 stringBuilder.reverse(); System.out.println(stringBuilder);// //替换字符串中的某些内容，左闭又开，如果end - start >str.length 则相当于替换+插入 stringBuilder.replace(4,6,"210"); System.out.println(stringBuilder);// //转换为String String str = stringBuilder.toString(); System.out.println(str); } } 

StringBuffer方法：线程安全

与StringBuffer有相同的使用方法

区别：是否线程安全，效率比较

十四. Java数组

Java语言中提供的数组是用来存储固定大小的同类型元素

声明数组变量+创建数组对象（实例化数组）

讯享网dataType[] arrayRefVar = new dataType[arraySize]; 

• 首先使用dataType[arraySize]构造方法创建了一个数组
• 将新创建的数组的引用传递给变量arrayRefVar

声明数组变量+创建数组对象+初始化

dataType[] arrayRefVar = { 
   value0,value1,...,valuen} 

处理数据

可以用for-each循环或者基本循环

注：当数组作为参数的时候，是引用传递，而不是值传递

Arrays类：包含了操纵数组的各种方法

• Arrays.sort()：对数组按照升序排序
• Arrays.toString()：返回数组的字符串形式
• Arrays.binarySearch(）:使用二分法寻找特定值，但数组调用前必须是排好序的
• Arrays.equals()：如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的
• Arrays.fill(int[] a, int val)：将指定的 int 值分配给指定 int 型数组指定范围中的每个元素

十五. Java日期时间

Date类

• 构造方法
  • 使用当前日期和时间进行初始化：Date
  • 接受一个参数，从1970年1月1日起的毫秒数
• 方法

  讯享网public class DateTest { 
        public static void main(String[] args) { 
        //创建一个当前日期 Date myDate = new Date(); System.out.println(myDate.toString()); //日期比较 Date myDate2 = new Date(99,1,28); //第一种：使用getTime()分别获区两个时间对象的毫秒数 long time1 = myDate.getTime(); long time2 = myDate2.getTime(); System.out.println(time1 > time2);//true //第二种：使用before,after,equals System.out.println(myDate.before(myDate2));//false System.out.println(myDate.after(myDate2));//true System.out.println(myDate.equals(myDate2));//false //第三种：使用compareTo System.out.println(myDate.compareTo(myDate2));//1 } } 

使用SimpleDateFormat格式化日期

//格式化日期 SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd,hh:mm:ss"); System.out.println(ft.format(myDate));//2022-03-09,06:44:05 

yyyy是完整的公历元年，MM是月份，dd是日期，hh是12小时制，HH是24小时制，ss是秒

使用printf格式化日期

使用两个字母格式：它以%t+一个字母结尾

讯享网//使用printf格式化日期 //输出全部日期和时间信息 System.out.printf("%tc%n",myDate); //年-月-日的格式 System.out.printf("%tF%n",myDate); //月/日/年格式 System.out.printf("%tD%n",myDate); //"HH:MM:SS PM"格式（12时制） System.out.printf("%tr%n",myDate); //"HH:MM:SS"格式（24时制） System.out.printf("%tT%n",myDate); //"HH:MM"格式（24时制） System.out.printf("%tR%n",myDate); 

解析字符串时间

SimpleDateFormat中的parse()方法，可以按照给定的格式来解析字符串

//解析字符串，返回Date SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd"); String dateString = "2022-03-09"; Date myDate3 = null; try { 
    myDate3 = dateFormat.parse(dateString); } catch (ParseException e) { 
    e.printStackTrace(); } System.out.println(myDate3.toString()); 

Java休眠

Thread.sleep(ms)——使当前线程进入到停滞状态，让出CPU的使用

讯享网 //java休眠 System.out.println(new Date()); Thread.sleep(1000*3); System.out.println(new Date()); 

Calendar类

Date可以格式化并创建一个日期对象，Calendar是一个抽象类，能设置和获取日期数据的特定部分

 //Calendar //创建一个代表系统当前日期的Calendar对象 Calendar c = Calendar.getInstance(); //设置具体的时间 c.set(2022,3,9); //设置具体月份 c.set(Calendar.MONTH,5); //获得年份 int year = c.get(Calendar.YEAR); System.out.println(year); //add:将月份➕10 c.add(Calendar.MONTH,2); System.out.println(c.get(Calendar.MONTH)); 

GregorianCalendar类

GregorianCalendar是Calendar类的一个具体实现。

讯享网//GregorianCalendar-具体实现的一个对象 GregorianCalendar gc = new GregorianCalendar(); System.out.println(gc.get(Calendar.MONTH));//2 //是否为闰年 System.out.println(gc.isLeapYear(gc.get(Calendar.YEAR)));//false 

十六.正则表达式

正则表达式语法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qvSTSmy8-35)(image-.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DJZLKusl-36)(image-021845.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lR3y7sPq-36)(image-039971.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SnZvJaZz-37)(image-.png)]

Pattern表示

pattern对象是一个正则表达式的编译表示，Pattern 类没有公共构造方法。要创建一个 Pattern 对象，必须首先调用其公共静态编译方法，它返回一个 Pattern 对象，接受一个正则表达式作为他的第一个参数

Pattern pattern = Pattern.compile(); 

Matcher类

Matcher 对象是对输入字符串进行解释和匹配操作的引擎。需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。

讯享网Matcher matcher = pattern.matcher(str); 

捕获组

捕获组是把字符串内多个字符当一个单独单元进行处理的方法，它通过对相应正则表达式一个括号内的字符分组来创建。

//判断是不是数字 public class RegularExpression { 
    public static void main(String[] args) { 
    String regex = "(-)?[0-9]+"; Pattern pattern = Pattern.compile(regex); String str1 = "123"; String str2 = "-123"; String str3 = "123%"; Matcher matcher1 = pattern.matcher(str1); Matcher matcher2 = pattern.matcher(str2); Matcher matcher3 = pattern.matcher(str3); System.out.println(matcher1.matches()); System.out.println(matcher2.matches()); System.out.println(matcher3.matches()); } } 

十七. Java方法

注意：System.out.println() 调用了系统类System中的标准输出对象out中的方法println()

方法的优点：

• 是程序变得简短而清晰
• 提高了代码的重用性
• 提高了程序开发的效率
• 有利于程序维护

方法的定义：

修饰符 返回值类型 方法名(参数类型 参数名){

​ … 方法体 …

讯享网 return 返回值; 

}

方法的重载：

创建另一个有相同名字但是参数不同的方法

注：重载的方法必须拥有不同的参数列表。不能仅仅依据修饰符或者返回类型的不同来重载方法。

public class Overload { 
    public static int max(int a, int b){ 
    return a > b ? a : b; } public static double max(double a, double b ){ 
    return a > b ? a : b; } public static void main(String[] args) { 
    System.out.println(max(1,2));//2 System.out.println(max(1.0,2.0));//2.0 } } 

构造方法

当一个对象被创建时，构造方法用来初始化对象。构造方法没有返回值，方法名与类名相同，且访问修饰符与类的访问修饰符相同。

注：不管是否自定义构造方法，所有的类都有默认的构造。

finalize()方法

Java 的内存回收可以由 JVM 来自动完成。如果你手动使用，则可以使用上面的方法。

十八. Java流（Stream）、文件（File）和IO

一个流可以理解为一个数据序列（支持多种格式），输入流表示从一个源读取数据，输出流表示向一个目标写数据。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-45zPCGlE-37)(iostream2xx.png)]

FileInputStream /FileOutputStream 字节流

从文件读取数据。

构造方法

• 使用字符串类型的文件名来创建一个输入流对象来读取文件

  讯享网InputStream f = new FileInputStream("C:/java/hello"); 

• 使用文件对象来创建输入流对象

File f = new File("C:/java/hello"); InputStream f = new FileInputStream("C:/java/hello"); 

Java目录

创建目录：

• mkdir()方法创建一个文件夹，成功则返回true，失败则返回false。失败表明File对象指定的路径已经存在，或者由于整个路径还不存在，该文件夹不能被创建。
• mkdirs()方法创建一个文件夹和它的所有父文件夹。

读取目录：

java读取目录和读取文件的操作一样，使用isDirectory()可以判断File对象是否为一个目录；使用list()，可以返回目录下包含的文件和目录

删除目录：

使用delete()方法删除目录，但是目录中应该不包含任何内容

十九. Java Scanner类

通过Scanner类来获取用户的输入

讯享网public class ScannerTest { 
    public static void main(String[] args) { 
    //创建一个Scanner类 // Scanner scanner = new Scanner(System.in); // if(scanner.hasNext()){ 
    // String str1 = scanner.next(); // System.out.println("输入的数据为："+str1); // } // scanner.close(); Scanner scan = new Scanner(System.in); double sum = 0; int m = 0; //直到输入一个非数字，即停止 while (scan.hasNextDouble()) { 
    double x = scan.nextDouble(); m = m + 1; sum = sum + x; } System.out.println(m + "个数的和为" + sum); System.out.println(m + "个数的平均值是" + (sum / m)); scan.close(); } 

二十. Java异常处理

异常是程序中的一些错误，但不是所有错误都是异常；

Exception类的层次

所有异常都是java.lang.Exception类的子类，

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-b2NQf87I-38)(image-.png)]

Error：是程序中无法处理的错误，表示运行应用程序中出现了严重的错误；此类错误一般表示代码运行时JVM出现问题，比如说当jvm耗完可用内存时，将出现OutOfMemoryError。此类错误发生时，JVM将终止线程。所以是非代码性错误。

Exception：程序本身可以捕获并可以处理的异常

• RuntimeException(不受检异常)：表示在JVM运行期间可能出现的错误，编译器不会检查此类异常，也不要求异常处理。比如用空值对象的引用（NullPointerException）、数组下标越界（ArrayIndexOutBoundException）。此类异常属于不可查异常，一般是由程序逻辑错误引起的，在程序中可以选择捕获处理，也可以不处理。
• IOException(受检异常)：Exception中除RuntimeException和其子类之外的异常。编译器会检查此类异常，如果程序中出现此类异常，比如说IOException，必须对该异常进行处理，要么使用try-catch捕获，要么使用throws语句抛出，否则编译不通过。

异常处理

• 抛出异常：throw, throws

  不处理异常

• 捕获异常：try,catch,finally–处理异常

  try { 
        // 程序代码 }catch(ExceptionName e1) { 
        //Catch 块 } 

  inally 关键字用来创建在 try 代码块后面执行的代码块。无论是否发生异常，finally 代码块中的代码总会被执行,即使catch中有return语句