Java

通过Java语言编写的应用程序在不同的系统 平台上都可以运行。

Java程序是在Java虚拟机上运行，而非直接运行于操作系统

就是使得jvm在构造对象的时候，帮助我们进行成员变量的初始化。

解决成员变量的隐藏的问题

访问对象的成员

访问对象的构造方法

随着类的加载而加载

优先于对象而存在

被类的所有成员所共享

可以通过类名访问

静态方法中是没有static关键字的

静态方法只能访问静态的成员变量和静态的成员方法

静态内容的存在于方法区中

所属不同

内存中的位置不同

内存出现时间不同

调用不同

在Java中，使用{}括起来的代码被称为代码块，根据其位置和声明的不同，可以进行分类

局部代码块

构造代码块

静态代码块

同步代码块

在Java源程序文件的第一行使用package声明可以使文件中定义的类成为指定包的成员

package 包名;

包名通常由多个名字字符串构成，中间用句点“.”分隔，每个名字表示的包称为其前面的名字表示的包的子包。

通常以组织机构的域名反转形式作为其所有包的通用前缀，比如：com.somecompany.apps

在类名前面加上类所属的包名，中间用句点“.”分隔，称为类的完全限定名(Full Qualified Name)，简称类的限定名

当在类体中使用了与当前类不同包的类名时，编译器编译时因为无法找到该类的定义而失败，有两个解决办法：

import <类的完全限定名>;

import声明一般紧跟在package声明之后，必须在类声明之前

Java语言核心包java.lang包中的类将被隐式导入，可以直接使用其中的类

import声明提供了一种包的智能导入方式import <包名>.*；
包中的类将根据需要导入，避免使用多条import声明

对应的典型的计算机语言, 例如: C

面向操作的

函数(方法)是程序的基本单位

对应的典型的计算机语言, 例如: Java, C++, C#

面向对象(object)的

类(class)是程序的基本单位

控制类中的成员，对其他类可见性(其他类是否可以直接使
用到)

通常用来限定，类库中的类(自定义数据类型)，对于外部使 用者的可见性(是否能使用该类型)。

任意类均访问，实际就是没有限制访问权限

同包中的其他类，和不同包的(可见)子类均可见

同包中的其他类可见

仅对同类中的其他成员可见

封装是一种信息隐藏技术。

在面向对象的编程中，用类来封装相关的数据和方法，保证了数据的安全和系统的严密性。

类

Java中的继承和我们现实生活中的“继承”的含义基本类似，但是含义更广。

被继承的类称之为父类(基类或超类)，继承其他类的类称之为子类(派生类)

子类可以通过继承机制，不写任何额外代码就可以拥有父类的“所有”成员。

a. 子类通过继承父类，子类就拥有了父类中定义的所有成员

b. 一旦子类继承了父类，子类 和 父类这两种类型有了关系

c.子类可以被当做父类类型来使用。
父类类型 引用 = new 子类类型();

class 子类名 extends 父类名 {}

代码复用(方法，类)

提高了代码的可维护性(这是一把双刃剑)

弱化Java中的类型约束(多态的前提)

父类的修改可能会出现在所有子类中(我们无法选择这些修改可以反应在，哪些子类中，不可以反应在哪些子类中)

在Java中只能实现单重继承，简单来说Java的extends关键字后只能跟一个类名

子类能够继承父类的私有成员，但是不能直接访问，可以定义方法进行间接访问

子类不能继承父类的构造方法

定义子类对象的过程

子类对象的两部分值

子类对象的初始化问题

a. 在子类中是否可以定义和父类同名的成员变量？ 

b. 如果可以，那么在子类中访问这个同名变量，究竟访问到的是父类对象中的值，
还是子类对象中的值？如果在父类中访问呢？

c. 是否可以在子类对象中，同时访问到子类对象和父类对象中的同名成员变量的值？

引入

问题

使用场景

注意事项

@Override注解检测子类方法是否覆盖父类方法

在子类中，覆盖父类方法的条件

测试跨包子类的访问权限
类体中可以直接访问父类中定义的被protected访问权限修饰符修饰的成员
通过父类对象不可以直接访问到该成员，
通过子类对象可以直接访问到该成员。

概念

a.修饰类，类不能被继承

b.修饰变量，变量就变成了常量，只能被赋值一次

final修饰变量时分为2种情况：

某一个事物，在不同时刻(或条件下)表现出来的不同状态。

1.继承（父类、子类）

2.发生多态的行为（方法），子类中子类必须覆盖父类中的该方法。

3.父类引用指向子类实例

a.编译时多态

b.运行时多态

成员变量

成员方法

编译看左边

提高了程序的维护性(由继承保证)

提高了程序的扩展性(由多态保证)

不能访问子类特有功能

向上转型

向下转型

疑问

从外部类的角度来理解，因为内部类定义在外部类的成员位置，如果说我们把内部类看做是一个整体，将内部类看做是外部类的一个“成员”

外部类的外部

外部类

private 

static

可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

可以访问到，方法体内部定义的局部变量

 被局部内部类访问的局部变量，被final修饰或 effectively final
 effectively final 就是一个常量，在初次赋值之后，其值再也没有变过
 为什么？ 生命周期
a. 局部变量的生命周期，随着方法的执行完毕，而被销毁
b. 当方法运行完毕之后，如果说内部对象还没有变成垃圾，
    并且可以通过内部类对象，访问到内部类对象的成员方法，
    此时局部内部类对象就有可能访问，局部变量，
    但此时，局部变量已经随着外部类方法的执行完毕而被销毁了
    已经访问不到了。

class Outer1 {
    public int num = 10;
    class Inner {
        public int num = 20;
        public void show() {
            int num = 30;
            // 类名.this 主要出现在嵌套的类定义中
            // 类名.this和static没有任何关系
            // 通过类名.this，来表明this那个类的当前对象
            // 此时的类名，只是用用来指明嵌套的层级
            System.out.println(Outer1.this.num);
            System.out.println(Inner.this.num); //这个this指的当前是内部类对象num成员变量
            System.out.println(num);
        }
    }
}
//在控制台分别输出10，20，30

因为本质上匿名内部类是一个继承了类或实现了接口的子类匿名对象

public Object();

public int hashCode()

public final Class getClass()

public String toString()

public boolean equals(Object obj)

protected void finalize()

protected Object clone()

创建一个空字符串

将一个字节数组代表的数值序列(ascII码表)，当做字符串创建

利用字节数组的一部分，来创建字符序列对象的字符串对象

创建一个字符数组多代表的字符序列对应的字符串对象

利用字符数组的一部分，来创建字符序列对象的字符串对象

获取字符串的长度

获取字符串中指定位置的字符

在字符串序列中查找指定字符在序列中首次出现的位置

在字符串序列中查找指定字符串在序列中首次出现的位置

让我们的程序，在运行过程，具有"自修复能力"的一种错误报告模型

指的是Exception及其直接子类(除了Runtimexception)

可预见的，语法层面强制在代码编写时处理

指的是RuntimeException及其直接子类

不可预见的，不要求在编写代码时必须处理

获取异常信息，返回字符串。

获取异常类名和异常信息，返回字符串。

获取异常类名和异常信息，以及异常出现在程序中的位置,并打印到控制台

该方法将异常内容保存在日志文件中，以便查阅。

无需显示处理，也可以和编译时异常一样处理

Java程序必须显示处理，否则程序就会发生错误无法通过编译

修饰符 返回值(形参列表) throws 异常列表 {}

异常列表之间用逗号分割，列表中出现的异常不要出现包含关系

方法覆盖时的子类异常列表必须与父类兼容

throw 异常对象

若要抛出编译时异常，则必须和throws配合起来使用

1.用在方法声明后面，跟的是异常类名
2.可以跟多个异常类名，用逗号隔开
3.表示抛出异常，由该方法的调用者来处理
4.throws表示出现异常的一种可能性，并不一定会发生这些异常

1.用在方法体内，跟的是异常对象名
2.只能抛出一个异常对象名
3.表示抛出异常，由方法体内的语句处理
4.throw则是抛出了异常，执行throw则一定抛出了某种异常

捕获并处理

向上抛出

原则

异常一旦被捕获，并且没有再次被抛出，那么上层是感知不到该异常的！！！！

在开发中，我们希望，不管程序，正常执行，非正常终止，都希望在某些代码运行完之后，一定能及时释放系统资源

a. final 最终的意思，修饰类，变量(成员变量和局部变量)，成员方法

b. finally 代码块

c. finalize() Object类中的一个方法

注意有双引号是双反斜杠

System.out.println(System.getProperty("user.dir"));

即使文件不是真的存在，运行也不会报错

在操作系统上物理创建文件

File file = new File("e:\\", "a.txt");//创建一个File类对象 e:\a.txt
boolean newFile = file.createNewFile();//物理创建
System.out.println(newFile);

当目标目录的父目录不存在的时候，mkdir()会创建布标目录失败

创建目录 e:\\aaa
file = new File("e:\\aaa");
boolean mkdir = file.mkdir();
System.out.println(mkdir);

当目标目录的父目录不存在的时候，mkdirs(),会连同目标目录和不存在的目标目录的父目录，一起创建出来

file = new File("e:\\aaa", "bbb");
boolean mkdirs = file.mkdirs();
System.out.println(mkdirs);

删除文件或目录, 如果此路径名表示一个目录，则该目录必须为空才能删除

//删除文件
File file = new File("e:\\a.txt");
boolean delete = file.delete();
System.out.println(delete);

//删除目录
File dir = new File("e:\\aaa");
System.out.println(dir.delete());
//e:\\aaa目录中有一个bbb目录，故返回false，删除失败

  a. 如果是目标文件对象和当前文件对象，在同一目录下，实现的效果就是重命名

b. 如果是目标文件对象和当前文件对象，不在同一目录下，除了重命名，文件移动

    //重命名： e:\a.txt -> e:\d.txt

//File targetFile1 = new File("e:\\d.txt");

File targetFile2 = new File("d:\\d.txt");

boolean result = file.renameTo(targetFile2);

System.out.println(result);

File file = new File("e:\\a.txt");
//System.out.println(file.isFile()); //true

file = new File("e:\\a");
//System.out.println(file.isFile());// false

File file = new File("e:\\a.txt");
//System.out.println(file.isDirectory()); //false

file = new File("e:\\a");
//System.out.println(file.isDirectory()); // true

物理判断File对象表示的文件或目录是否真的存在

file = new File("e:\\zs\\a.txt");
System.out.println(file.exists());//true or false

File file = new File("a.txt");
System.out.println(file.getAbsolutePath()); //E:\wangdao\20th\exception&file\a.txt
System.out.println(System.getProperty("user.dir"));//E:\wangdao\20th\exception&file
System.out.println(file.getPath()); //返回的就是创建File对象时，所使用的字符串路径//a.txt
System.out.println(file.getName()); //文件名或者目录名//a.txt

File file = new File("e:\\zs\\a.txt");
System.out.println(file.getAbsolutePath()); //e:\zs\a.txt
System.out.println(file.getPath()); //e:\zs\a.txt
System.out.println(file.getName()); //a.txt

返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
 如果此抽象路径名不表示一个目录，那么此方法将返回 null

//一个File类对象可以表示一个目录
File dir = new File("e:\\a");
String[] list = dir.list();
System.out.println(Arrays.toString(list)); //[b, zs.txt]

返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的目录和文件
如果此抽象路径名不表示一个目录，那么此方法将返回 null

File[] files1 = dir.listFiles();
System.out.println(Arrays.toString(files1));//[e:\a\b, e:\a\zs.txt]

输入流 读入数据

输出流 写出数据

字节流：数据是一连串01二进制数据

字符流：数据是字符序列

将指定的字节写入此输出流。write 的常规协定是：向输出流写入一个字节。要写入的字节是参数 b 的八个低位。b 的 24 个高位将被忽略。

将 b.length 个字节从指定的 byte 数组写入此输出流

将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流

1. FileoutputStream会现在操作系统中，找目标文件

a. 如果说目标文件不存在，FileoutputStream创建这个文件

b. 如果该文件存在，则不再重新创建

2. 在内存中，创建FileOutputStream对象，并建立数据传输的通道

关闭此输出流并释放与此流有关的所有系统资源。

不同的操作系统，换行符不一样

windows操作系统： '\r''\n'

linux,Mac OS: '\n'

对于一些高级记事本，都可以识别

a. 如果在创建FileOutputStream对象的时候，目标文件已经存在

FileOutputStream对象，它会自动清空，已经存在的文件内容

从文件的最开始出，开始写入



FileOutputStream(File file, boolean append)

创建一个向指定 File 对象表示的文件中写入数据的文件输出流。如果第二个参数为 true，

则将字节写入文件末尾处，而不是写入文件开始处





FileOutputStream(String name, boolean append)

创建一个向具有指定 name 的文件中写入数据的输出文件流。