java入门笔记——老王笔记--IT隐匿者

Java笔记

类只是为所有的对象定义了抽象的属性与行为。

（1）Java中finally与return的执行顺序

在 Java 的异常处理中，try、catch 和 finally 是按顺序执行的。如果 try 中没有异常，则顺序为 try→finally，如果 try 中有异常，则顺序为 try→catch→finally。但是当 try、catch、finally 中加入 return 之后，return 和 finally 的执行顺序让很多人混淆不清。下面来分别说明一下。

1. try 和 catch 中带有 return

1）try 中带有 return

public class tryDemo {    
public static int show() {        
try {            
return 1;        } 
finally {            
System.out.println("执行finally模块");        
}    
}    
public static void main(String args[]) {        
System.out.println(show());    
}
}

输出结果如下：

执行finally模块
1

2）try 和 catch 中都带有 return

public class tryDemo {    
public static int show() {        
try {            
int a = 8 / 0;            
return 1;        } 
catch (Exception e) {            
return 2;        } 
finally {            
System.out.println("执行finally模块");        } 
}    
public static void main(String args[]) {        
System.out.println(show());    
}
}

输出结果为：
执行finally模块
2

当 try 代码块或者 catch 代码块中有 return 时，finally 中的代码总会被执行，且 finally 语句 return 返回之前执行。

注意：可以使用编译器的 Debug 功能查看详细过程。如果不了解如何使用 Debug 功能可参考《Java Eclipse如何调试代码》一节。

2. finally 中带有 return

public class tryDemo {    
public static int show() {        
try {            
int a = 8 / 0;            
return 1;        } 
catch (Exception e) 
{            
return 2;        
} 
finally {            
System.out.println("执行finally模块");            
return 0;        
}    
}    
public static void main(String args[]) {        
System.out.println(show());   
}
}

输出结果如下：

执行finally模块
0

当 finally 有返回值时，会直接返回该值，不会去返回 try 代码块或者 catch 代码块中的返回值。

注意：finally 代码块中最好不要包含 return 语句，否则程序会提前退出。

3. finally 中改变返回值

下面先来看 try 代码块或者 catch 代码块中的返回值是普通变量时，代码如下：

public class tryDemo {    
public static int show() {        
int result = 0;        
try {            
return result;        } 
finally {            
System.out.println("执行finally模块");            
result = 1;        }    
}    
public static void main(String args[]) {        
System.out.println(show());    }
}

输出结果为：
执行finally模块
0

由输出结果可以看出，在 finally 代码块中改变返回值并不会改变最后返回的内容。

当返回值类型是引用类型时，结果也是一样的，代码如下：

public class tryDemo {    
public static Object show() {        
Object obj = new Object();        
try {            
return obj;        } 
finally {            
System.out.println("执行finally模块");            
obj = null;        
}    
}    
public static void main(String args[]) {        
System.out.println(show());    }}

输出结果为：
执行finally模块
java.lang.Object@15db9742

当 try 代码块或 catch 代码块中的 return 返回值类型为普通变量或引用变量时，即使在后面 finally 代码块中对返回值的变量重新赋值，也不会影响最后返回的值。

总结为以下几条：

• 当 try 代码块和 catch 代码块中有 return 语句时，finally 仍然会被执行。
• 执行 try 代码块或 catch 代码块中的 return 语句之前，都会先执行 finally 语句。
• 无论在 finally 代码块中是否修改返回值，返回值都不会改变，仍然是执行 finally 代码块之前的值。
• finally 代码块中的 return 语句一定会执行。

（2）为什么使用向上转型而不直接创建子类对象？

初学者在学习向上转型可能会很难理解，向上转型并不能调用子类特有属性和方法，我们必须先生成子类实例再赋值给父类引用（向上转型），然后将父类引用向下强制转换给子类引用（向下转型），这样才能调用子类中的所有成员。这看起来像是多次一举，还不如直接创建子类实例。

随着技术的提升，我们在学习其它开源项目时会发现很多地方都用了向上转型和向下转型的技术。本节将带大家了解向上转型和向下转型的意义及使用场景。

例 1

定义父类 Animal，代码如下：

public class Animal {    
public void sleep() {        
System.out.println("小动物在睡觉");    }    
public static void doSleep(Animal animal) {  
// 此时的参数是父类对象，但是实际调用时传递的是子类对象，就是向上转型。
//为何doSleep(Animal animal),为何参数是Animal，因为想用向上转型（Animal animal=new Cat();)
//向下转型：Cat cat=(Cat)new Animal();
//如果不用向上转型，那就得写两个doSleep办法，一个参数为Cat cat 一个参数为Dog dog,那代码就重复了
//向上转型更好的体现了类的多态性

animal.sleep();    }    
public static void main(String[] args) {    
Animal animal1=new Cat();//向上转型
Animal animal2=new Dog();//向上转型
animal.doSleep(animal1);       
animal.doSleep(animal2);    
}
}

子类 Cat 代码如下：

public class Cat extends Animal {    
@Override    
public void sleep() {        
System.out.println("猫正在睡觉");    }}

子类 Dog 代码如下：

public class Dog extends Animal {    
@Override    public void sleep() {        
System.out.println("狗正在睡觉");    
}}

输出结果为：
猫正在睡觉
狗正在睡觉

如果不用向上转型则必须写两个 doSleep 方法，一个传递 Cat 类对象，一个传递 Dog 类对象。这还是两个子类，如果有多个子类就要写很多相同的方法，造成重复。可以看出向上转型更好的体现了类的多态性，增强了程序的间接性以及提高了代码的可扩展性。当需要用到子类特有的方法时可以向下转型，这也就是为什么要向下转型。

比如设计一个父类 FileRead 用来读取文件，ExcelRead 类和 WordRead 类继承 FileRead 类。在使用程序的时候，往往事先不知道我们要读入的是 Excel 还是 Word。所以我们向上转型用父类去接收，然后在父类中实现自动绑定，这样无论你传进来的是 Excel 还是 Word 就都能够完成文件读取。

总结如下：

1. 把子类对象直接赋给父类引用是向上转型，向上转型自动转换。如 Father father = new Son();
2. 指向子类对象的父类引用赋给子类引用是向下转型，要强制转换。使用向下转型，必须先向上转型，为了安全可以用 instanceof 运算符判断。 如 father 是一个指向子类对象的父类引用，把 father 赋给子类引用 son，即Son son =（Son）father;。其中 father 前面的(Son)必须添加，进行强制转换。
3. 向上转型不能使用子类特有的属性和方法，只能引用父类的属性和方法，但是子类重写父类的方法是有效的。
4. 向上转型时会优先使用子类中重写父类的方法，如例 1 中调用的 sleep 方法。
5. 向上转型的作用是减少重复代码，可以将父类作为参数，这样使代码变得简洁，也更好的体现了多态。

（3）Java抽象类和接口的区别

1）抽象类

在 Java 中，被关键字 abstract 修饰的类称为抽象类；被 abstract 修饰的方法称为抽象方法，抽象方法只有方法声明没有方法体。

抽象类有以下几个特点：

1. 抽象类不能被实例化，只能被继承。
2. 包含抽象方法的类一定是抽象类，但抽象类不一定包含抽象方法（抽象类可以包含普通方法）。
3. 抽象方法的权限修饰符只能为 public、protected 或 default，默认情况下为 public。
4. 一个类继承于一个抽象类，则子类必须实现抽象类的抽象方法，如果子类没有实现父类的抽象方法，那子类必须定义为抽象类。
5. 抽象类可以包含属性、方法、构造方法，但构造方法不能用来实例化对象，只能被子类调用。

2）接口

接口可以看成是一种特殊的类，只能用 interface 关键字修饰。

Java 中的接口具有以下几个特点：

1. 接口中可以包含变量和方法，变量被隐式指定为 public static final，方法被隐式指定为 public abstract（JDK 1.8 之前）。
2. 接口支持多继承，即一个接口可以继承（extends）多个接口，间接解决了 Java 中类不能多继承的问题。
3. 一个类可以同时实现多个接口，一个类实现某个接口则必须实现该接口中的抽象方法，否则该类必须被定义为抽象类。

3）抽象类和接口的区别

接口和抽象类很像，它们都具有如下特征。

• 接口和抽象类都不能被实例化，主要用于被其他类实现和继承。
• 接口和抽象类都可以包含抽象方法，实现接口或继承抽象类的普通子类都必须实现这些抽象方法。

但接口和抽象类之间的差别非常大，这种差别主要体现在二者设计目的上。下面具体分析二者的差别。

接口作为系统与外界交互的窗口，接口体现的是一种规范。对于接口的实现者而言，接口规定了实现者必须向外提供哪些服务（以方法的形式来提供）；对于接口的调用者而言，接口规定了调用者可以调用哪些服务，以及如何调用这些服务（就是如何来调用方法）。当在一个程序中使用接口时，接口是多个模块间的耦合标准；当在多个应用程序之间使用接口时，接口是多个程序之间的通信标准。

从某种程度上来看，接口类似于整个系统的“总纲”，它制定了系统各模块应该遵循的标准，因此一个系统中的接口不应该经常改变。一旦接口被改变，对整个系统甚至其他系统的影响将是辐射式的，会导致系统中大部分类都需要改写。

抽象类则不一样，抽象类作为系统中多个子类的共同父类，它所体现的是一种模板式设计。抽象类作为多个子类的抽象父类，可以被当成系统实现过程中的中间产品，这个中间产品已经实现了系统的部分功能（那些已经提供实现的方法），但这个产品依然不能当成最终产品，必须有更进一步的完善，这种完善可能有几种不同方式。

除此之外，接口和抽象类在用法上也存在差别，如下表所示：

参数	抽象类	接口
实现	子类使用 extends 关键字来继承抽象类，如果子类不是抽象类，则需要提供抽象类中所有声明的方法的实现。	子类使用 implements 关键字来实现接口，需要提供接口中所有声明的方法的实现。
访问修饰符	可以用 public、protected 和 default 修饰	默认修饰符是 public，不能使用其它修饰符
方法	完全可以包含普通方法	只能包含抽象方法、静态方法、默认方法和私有方法，不能为普通方法提供方法实现
变量	既可以定义普通成员变量，也可以定义静态常量	只能定义静态常量，不能定义普通成员变量
构造方法	抽象类里的构造方法并不是用于创建对象，而是让其子类调用这些构造方法来完成属于抽象类的初始化操作	没有构造方法
初始化块	可以包含初始化块	不能包含初始化块
main 方法	可以有 main 方法，并且能运行	没有 main 方法
与普通Java类的区别	抽象类不能实例化，除此之外和普通 Java 类没有任何区别	是完全不同的类型
运行速度	比接口运行速度要快	需要时间去寻找在类种实现的方法，所以运行速度稍微有点慢

一个类最多只能有一个直接父类，包括抽象类，但一个类可以直接实现多个接口，通过实现多个接口可以弥补 Java 单继承的不足。

4）抽象类和接口的应用场景

抽象类的应用场景：

1. 父类只知道其子类应该包含怎样的方法，不能准确知道这些子类如何实现这些方法的情况下，使用抽象类。
2. 从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。

接口的应用场景：

1. 一般情况下，实现类和它的抽象类之前具有 “is-a” 的关系，但是如果我们想达到同样的目的，但是又不存在这种关系时，使用接口。
2. 由于 Java 中单继承的特性，导致一个类只能继承一个类，但是可以实现一个或多个接口，此时可以使用接口。

什么时候使用抽象类和接口：

• 如果拥有一些方法并且想让它们有默认实现，则使用抽象类。
• 如果想实现多重继承，那么必须使用接口。因为 Java 不支持多继承，子类不能继承多个类，但可以实现多个接口，因此可以使用接口。
• 如果基本功能在不断改变，那么就需要使用抽象类。如果使用接口并不断需要改变基本功能，那么就需要改变所有实现了该接口的类。

（4）Java File类（文件操作类）详解

在 Java 中，File 类是 java.io 包中唯一代表磁盘文件本身的对象，也就是说，如果希望在程序中操作文件和目录，则都可以通过 File 类来完成。File 类定义了一些方法来操作文件，如新建、删除、重命名文件和目录等。

File 类不能访问文件内容本身，如果需要访问文件内容本身，则需要使用输入/输出流。

File 类提供了如下三种形式构造方法。

1. File(String path)：如果 path 是实际存在的路径，则该 File 对象表示的是目录；如果 path 是文件名，则该 File 对象表示的是文件。
2. File(String path, String name)：path 是路径名，name 是文件名。
3. File(File dir, String name)：dir 是路径对象，name 是文件名。

使用任意一个构造方法都可以创建一个 File 对象，然后调用其提供的方法对文件进行操作。在表 1 中列出了 File 类的常用方法及说明。

方法名称	说明
boolean canRead()	测试应用程序是否能从指定的文件中进行读取
boolean canWrite()	测试应用程序是否能写当前文件
boolean delete()	删除当前对象指定的文件
boolean exists()	测试当前 File 是否存在
String getAbsolutePath()	返回由该对象表示的文件的绝对路径名
String getName()	返回表示当前对象的文件名或路径名（如果是路径，则返回最后一级子路径名）
String getParent()	返回当前 File 对象所对应目录（最后一级子目录）的父目录名
boolean isAbsolute()	测试当前 File 对象表示的文件是否为一个绝对路径名。该方法消除了不同平台的差异，可以直接判断 file 对象是否为绝对路径。在 UNIX/Linux/BSD 等系统上，如果路径名开头是一条斜线/，则表明该 File 对象对应一个绝对路径；在 Windows 等系统上，如果路径开头是盘符，则说明它是一个绝对路径。
boolean isDirectory()	测试当前 File 对象表示的文件是否为一个路径
boolean isFile()	测试当前 File 对象表示的文件是否为一个“普通”文件
long lastModified()	返回当前 File 对象表示的文件最后修改的时间
long length()	返回当前 File 对象表示的文件长度
String[] list()	返回当前 File 对象指定的路径文件列表
String[] list(FilenameFilter)	返回当前 File 对象指定的目录中满足指定过滤器的文件列表
boolean mkdir()	创建一个目录，它的路径名由当前 File 对象指定
boolean mkdirs()	创建一个目录，它的路径名由当前 File 对象指定
boolean renameTo(File)	将当前 File 对象指定的文件更名为给定参数 File 指定的路径名

File 类中有以下两个常用常量：

• public static final String pathSeparator：指的是分隔连续多个路径字符串的分隔符，Windows 下指;。例如 java -cp test.jar;abc.jar HelloWorld。
• public static final String separator：用来分隔同一个路径字符串中的目录的，Windows 下指/。例如 C:/Program Files/Common Files。

注意：可以看到 File 类的常量定义的命名规则不符合标准命名规则，常量名没有全部大写，这是因为 Java 的发展经过了一段相当长的时间，而命名规范也是逐步形成的，File 类出现较早，所以当时并没有对命名规范有严格的要求，这些都属于 Java 的历史遗留问题。

Windows 的路径分隔符使用反斜线“\”，而 Java 程序中的反斜线表示转义字符，所以如果需要在 Windows 的路径下包括反斜线，则应该使用两条反斜线或直接使用斜线“/”也可以。Java 程序支持将斜线当成平台无关的路径分隔符。

假设在 Windows 操作系统中有一文件 D:\javaspace\hello.java，在 Java 中使用的时候，其路径的写法应该为 D:/javaspace/hello.java 或者 D:\\javaspace\\hello.java。

1)获取文件属性

在 Java 中获取文件属性信息的第一步是先创建一个 File 类对象并指向一个已存在的文件， 然后调用表 1 中的方法进行操作。

假设有一个文件位于 C:\windows\notepad.exe。编写 Java 程序获取并显示该文件的长度、是否可写、最后修改日期以及文件路径等属性信息。实现代码如下：

public class Test02 {    
public static void main(String[] args) {        
String path = "C:/windows/"; // 指定文件所在的目录        
File f = new File(path, "notepad.exe"); // 建立File变量,并设定由f变量引用        System.out.println("C:\\windows\\notepad.exe文件信息如下：");        System.out.println("============================================");        
System.out.println("文件长度：" + f.length() + "字节");        
System.out.println("文件或者目录：" + (f.isFile() ? "是文件" : "不是文件"));        
System.out.println("文件或者目录：" + (f.isDirectory() ? "是目录" : "不是目录"));        
System.out.println("是否可读：" + (f.canRead() ? "可读取" : "不可读取"));        
System.out.println("是否可写：" + (f.canWrite() ? "可写入" : "不可写入"));        
System.out.println("是否隐藏：" + (f.isHidden() ? "是隐藏文件" : "不是隐藏文件"));        
System.out.println("最后修改日期：" + new Date(f.lastModified()));        
System.out.println("文件名称：" + f.getName());        
System.out.println("文件路径：" + f.getPath());        
System.out.println("绝对路径：" + f.getAbsolutePath());    }}

在上述代码中 File 类构造方法的第一个参数指定文件所在位置，这里使用C:/作为文件的实际路径；第二个参数指定文件名称。创建的 File 类对象为 f，然后通过 f 调用方法获取相应的属性，最终运行效果如下所示。

C:\windows\notepad.exe文件信息如下：
============================================
文件长度：193536字节
文件或者目录：是文件
文件或者目录：不是目录
是否可读：可读取
是否可写：可写入
是否隐藏：不是隐藏文件
最后修改日期：Mon Dec 28 02:55:19 CST 2016
文件名称：notepad.exe
文件路径：C:\windows\notepad.exe
绝对路径：C:\windows\notepad.exe

2)创建和删除文件

File 类不仅可以获取已知文件的属性信息，还可以在指定路径创建文件，以及删除一个文件。创建文件需要调用 createNewFile() 方法，删除文件需要调用 delete() 方法。无论是创建还是删除文件通常都先调用 exists() 方法判断文件是否存在。

假设要在 C 盘上创建一个 test.txt 文件，程序启动时会检测该文件是否存在，如果不存在则创建；如果存在则删除它再创建。

实现代码如下：

public class Test03 {    public static void main(String[] args) throws IOException {        File f = new File("C:\\test.txt"); // 创建指向文件的File对象        if (f.exists()) // 判断文件是否存在        {            f.delete(); // 存在则先删除        }        f.createNewFile(); // 再创建    }}

运行程序之后可以发现，在 C 盘中已经创建好了 test.txt 文件。但是如果在不同的操作系统中，路径的分隔符是不一样的，例如：

• Windows 中使用反斜杠\表示目录的分隔符。
• Linux 中使用正斜杠/表示目录的分隔符。<