java基础知识

java基础知识

程序运行时的内存占用

代码区 (code area) 存放程序的代码不妨

数据区 (data area) 存放程序的全局数据和静态数据

堆区 (heap area) 存放程序动态申请的数据

栈区 (stack area) 存放程序的局部数据和参数

static

用在某个成员函数或者变量上时，它就不再局限于该类的对象。

用static修饰的属性叫静态属性又叫类变量，用static修饰的方法被称为静态方法，又被称为类方法（不能有this）

可以用来修饰初始化语句块，这样的语句块常 称为静态初始化语句块（要跟非静态初始化语 句块区分开来）

没有创建该类具体对象，该类的static成员也会存在 类名.名

静态代码块 非静态代码块：

相同点

都是在jvm加载类时且构造方法执行之前 执行，在类中都可以定义多个。

一般在代码块中对一些static变量进行赋值。

不同点

静态代码块只在第一次new执行一次，之后 不再执行，而非静态代码块在每new一次就 执行一次

静态代码块

一． 静态代码块只能定义在类里面，它独立于任何 方法，不能定义在方法里面。

二． 静态代码块里面的变量都是局部变量，只在本 块内有效。

三． 静态代码块会在类被加载时自动执行，而无论 加载者是JVM还是其他的类。

四． 一个类中允许定义多个静态代码块，执行的顺 序根据定义的顺序进行。

五． 静态代码块只能访问类的静态成员，而不允许 访问实例成员。

封装

含义

一层含义是把对象的属性和行为看成为一个密不可 分的整体，将这两者封装在一个不可分割的独立单 位（即对象）中。

另一层含义指信息隐藏，把不需要让外界知道的信 息隐藏起来，有些对象的属性及行为允许外界用户 知道或使用，但不允许更改，而另一些属性和行为 则不允许外界知晓或只允许使用对象的功能，而尽 可能隐藏对象的功能实现细节。

必要性

不使用封装，很容易复制错误，同时信息不安全

访问控制修饰符

修饰符	访问权限
public	对外公开
protected	向子类以及同一个包中类开放
default	向同一个包中的类开放
private	只有类本身可以访问

Java类的访问级别

修饰符	访问权限
public	可以被所有其他类访问
default	只能被同一个包中类访问

继承

is a 关系

定义

• 继承是使用已存在的类的定义作为基础，建立新类 的技术；

• 继承是在保留原有类的数据成员和成员函数的基础 上，派生出新类，新的类可以有某种程度的变异；

• 通过继承，新类自动具有了原有类的所有数据成员和成员函数，因而只需定义原有类型没有的新的数据成员和成员函数。实现了软件复用，使得类之间具备了层次性；

• 通过继承和派生形成的类族，反映了面向对象问题域主题等概念。

类的继承

• 被继承的类称为父类（superclass）,继承后产 生的类称为子类（subclass）。
• 如果子类只能有一个直接父类，称为单继承。
• 多继承：如果子类可以有多个直接父类，称为多继承。
• java中是单继承

基类和派生类的关系

• 基类是对若干个派生类的抽象
• 派生类是基类的具体化
• 派生类可以看作基类定义的延续

格式

[修饰符]class 类名 extends 父类名
{
类体；
}

子类构造函数

• 构造函数不能被继承
• 子类构造函数中，通过super([参数1，参数2…]),调用父类的构造函数
• 初始化顺序，父类属性->子类属性
• 子类的构造函数中必须先调用父类构造函数（出现在第一句）

super关键字

相当于父类的引用

可通过

super.方法名

调用父类中的同名方法

this关键字

相当于自身的引用

变量名隐藏

子类中定义了父类中同名变量， 此时称为子类隐藏（override）了 父类的成员变量。

可通过super.变量名调用父类变量

方法覆盖

在子类中重写父类的方法， 它们的名称、参数以及返回类型完全相 同。

向上转型

• 将子类转换成父类，在继承关系上面是向 移动的，所以一般称之为向上转型或者 向上映射。
• 由于向上转型是从一个叫专用类型向较通 用类型转换，所以它总是安全的，唯一发生变化的可能就是属性和方法的丢失。
• 这就是为什么编译器在“未曾明确表示转 型”或者“未曾指定特殊标记”的情况下，仍然允许向上转型的原因。
• 将在多态性使用到

protected的使用

如果基类仅向其派生类提供服务，而不对其他客户提供该服务，使用protected成员访问说明符是合适的

关于访问权限

一个类对一个方法或变量的访问，是指在该类的方法中访问。

多态

首先类看几个定义。

关键字abstract

抽象方法，即该方法没有具体实现（即仅定义一个名称

抽象类，该类中有抽象方法方法

有抽象方法的类一定是抽象类

public abstract void a();//抽象方法的声明
public class abstract a{...}//抽象类的声明

抽象类因为有抽象方法，因此不能有实例。

抽象类的继承

抽象类可以有子类，子类需对父类中所有的抽象类方法进行实现

否则，子类仍为抽象类

多态

多态是指拥有共同父类的类，调用相同方法时，结果产生的多样性。

多态能极大减少代码量，同时体现面向对象编程的思想。

说到这里可能还对多态不是很清楚，来个例子

public class abstract Shape{//定义shape类
public abstract double getArea();
}

定义了一个Shape抽象类，它可以有正方形，圆等子类，要求实现正方形、圆的getArea();方法。

首先假设Shape中没有抽象方法（即Shape是一个普通类）。那我们为了实现需求，需要在正方形，圆类中分别实现他们自身的getArea()方法，在调用时需要分别通过自身实例调用getArea()，目前来看，这种行为还是很正常的。

但是，如果我们有需求构建一个方法，传入参数是各种图形类，并且需要求面积，那该如何解决呢？使用重载，为每个子类定义一个同名方法？

代码冗余极大！

这里就需要用到继承的向上转型知识点了。

即子类对象可以向上转型为父类对象，而该父类对象能调用子类的方法。

也就是说，我们可以仅仅定义一个方法，将参数中的子类替换为父类。

然而，这时候又有一个问题，如果使用父类对象，调用父类的getArea()方法时，怎么知道调用哪一个?

这里就有了解决方案，在父类中定义一个getArea()的抽象方法（也可以不是），并在子类中实现，则调用由子类对象向上转型得到的父类对象的getArea()时，会自动调用子类的getArea()方法。

是不是觉得很奇妙？

多态是在父类中定义了一套接口，具体实现在子类中各不相同，这就是多态。

即子类对父类中的方法进行重写，在子类的对象中将父类中的方法覆盖。

ps：子类中重写的方法的访问权限不能低于父类中的访问权限，否则会无法覆盖，进而编译出错。

接口

讲完多态，当然要讲一讲接口啦。

接口跟多态本质上是一样的，唯一的区别是，拥有同一套接口的类不必有共同的父类（话说继承 externs 貌似是用接口 implements 实现的？）

接口

不相关类的相同行为的抽象

接口声明

inerface a{
}

接口体仅包括常量，以及抽象方法的声明。

其中常量为static ，方法及常量的访问权限为public，控制修饰符等均可省略

实现接口

class b implements a{

}

一个类可以有多个接口，但是在类体中需要对接口中的抽象方法实现（重写）（否则为抽象类）

接口回调

把实现某一接口的类创建的对象引用赋给该接口声明的接口变量，该接口变量就可以调用被类实现的接口中的方法。

多态？

可声明接口对象，用实现该接口的类的对象赋值。与多态中的向上转型极其相似。

接口间关系

接口间可多继承

内部类与异常类

内部类

class Outer{
int ha=1;
class Inner{
int haha = Outer.this.ha;//引用外嵌类属性
}
}
class Test{
Outer.Inner io = new Outer().new Inner();//创建实例

}

定义在一个类中的类，被称为内部类，而内部类所在的类被称为内部类的外嵌类

内部类和外嵌类间的关系

• 内部类的外嵌类的成员变量在内部类中有效

• 内部类中不能再定义类

• 内部类中不能定义类属性和类方法，外嵌类的类体中可以用内部类声明对象作为外嵌类的成员

• 内部类仅供它的外嵌类使用，其他类不可用某个类的外部类声明对象

其他

内部类生成的字节码文件名字格式为 外嵌类名称$内部类名

内部类可以被修饰为static内部类，那么static内部类就是外嵌类中的一种静态数据类型，就能再其他类中创建内部类对象，但是不能操作外嵌类实例成员变量

非内部类不可以是static类

匿名类

不显式的声明一个类的子类，又想用该类创建一个对象，这就需要用到匿名类。

例：A是一个类，若想创建它的一个子类的对象（匿名类）

new A(){
    //匿名类的类体
}

特点

可以继承父类方法也可以重写父类方法

使用匿名类时，必是一个内部类，拥有内部类的性质

匿名类与接口

可创建一个实现接口的匿名类。

new c(){
//实现接口的匿名类的类体
}

异常类

java使用throw关键字抛出一个Exception子类的实例表示异常发生。

try-catch 语句

将可能出现异常的语句放在try部分，相对应的处理放在catch处

try{
//包含可能发生异常的语句
}
catch(ExceptionsSubclass a){
//异常a处理
}
catch(ExceptionsSubclass b){
//异常b处理
}

各个catch参数中的异常类都是Exception的某个子类，这些子类中不能有父子关系，否则保留一个父类即可。

自定义异常类

继承Exception定义自己的异常类，然后根据程序需要规定哪些方法会抛出这种异常。使用throws关键字声明会抛出异常列表，throw关键字抛出异常

public class myException extends Exception{
//自定义异常类类体
}
public class test{
public void haha() throws myException{
    if(...){
        throw myException;
    }
//....
}
}

例：自定义了一个myException异常类

import java.util.Scanner;
class myException extends Exception{

}
public class test {

    public static void haha() throws myException {
    throw new myException();
    }
    public static void main (String args[]){
        try {
        haha();
        }
        catch(myException a){
            System.out.println("catch");
            return;
            
        }
        finally{
            System.out.println("this is finally");
        }
    }
}

throws 方法体抛出的异常
重写方法抛出的异常的范围不能比被重写的方法的范围大

输出结果：finally 内语句被执行

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UXhUqCYd-1618988878153)(java%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86.assets/1618750994973.png)]

将catch中的return改为System.exit(0)

输出结果：finally内语句未执行

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J0QtDQWX-1618988878154)(java%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86.assets/1618751065369.png)]

断言

断言用于处理一些程序不准备通过捕获异常处理的错误。

语法

断言式语句的格式

assert booleanExpression;
assert booleanExpression :messageException;

若布尔表达式的值为false，则程序停止执行，并输出messageException（若有）

启动与关闭断言语句

使用java解释器直接运行程序时默认关闭断言语句1

java -ea ...

实例：要求输入的a！=0

若a为0，则程序停止执行，并将错误信息输出。

assert要用 -ea 命令开启

以下是测试的输出结果

import java.util.Scanner;

public class test {
    public static void main(String args[]){
        int a;
        Scanner in = new Scanner(System.in);
        a=in.nextInt();
        assert a!=0:"input illegal";
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-53SWwr0f-1618988878155)(java%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86.assets/1618749715254.png)]

finally语句

若try catch语句中调用了return， finally仍执行

若调用了System.exit(0),则不执行

常用实用类

String类

final类

构造String对象

输入流输出流

程序在运行时，可能需要从外部存储媒介或其他程序读取所需要的数据。

File类

构造方法

File in = new File(String filePath);
File in = new File(String dirPath,String fileName);
File in = new File(File dir,String fileName);

常用方法

功能一目了然

public String getName();//获取名称
public boolean canRead();//是否可读
public boolean canWrite();//是否可写
public boolean canExecute();//是否可执行
public boolean exists();//是否存在
public String getAbsolutePath();//绝对路径
public String getParent();//父目录
public boolean isFile();//
public boolean isDirectory();
...

若该File对象为目录

public String[] list();//以字符串形式返回目录下的全部文件
public File[] listFiles();//用File对象形式返回目录下的全部文件

若需要限定输出的文件类型，则可以

public String[] list(FilenameFilter obj);//以字符串形式返回目录下的全部文件
public File[] listFiles(FilenameFilter obj);//用File对象形式返回目录下的全部文件

需要传递一个实现了FilenameFilter接口的对象，重写accept方法例

import java.io.File;
import java.io.FilenameFilter;

public class fileAccept implements FilenameFilter {//其实是对文件名进行匹配
    public String extendName;
    public void SetExtendName(String s){//s为要匹配的后缀名
        extendName="."+s;
    }
    public boolean accept(File dir, String name){
        return name.endsWith(extendName);
    }
}

创建目录

public boolean mkdir();//创建目录，成功返回true，失败或已存在返回false，目录名由绝对路径指定

文件的创建于与删除

当使用File类创建一个文件对象和，若不存在该文件，则可创建文件

public boolean createNewFile();

删除文件

public boolean delete();

运行可执行文件

首先使用Runtime类声明一个对象，再使用该类的静态方法创建这个对象

Runtime ec;
ec = Runtime.getRuntime();

ec可以调用以下代码，打开可执行文件或执行一个操作

exec(String command);

command 可以为可执行文件的绝对路径

文件字节输入流

• 设定输入流的源
• 创建指向源的输入流
• 让输入流读取源中的数据
• 关闭输入流

FileInputStream基本语法

构造方法

FileInputStream(String name);
FileInputStream(File file);

public boolean mkdir();//创建目录，成功返回true，失败或已存在返回false，目录名由绝对路径指定

#### 文件的创建于与删除

当使用File类创建一个文件对象和，若不存在该文件，则可创建文件

```java
public boolean createNewFile();

删除文件

public boolean delete();

运行可执行文件

首先使用Runtime类声明一个对象，再使用该类的静态方法创建这个对象

Runtime ec;
ec = Runtime.getRuntime();

ec可以调用以下代码，打开可执行文件或执行一个操作

exec(String command);

command 可以为可执行文件的绝对路径

文件字节输入流

• 设定输入流的源
• 创建指向源的输入流
• 让输入流读取源中的数据
• 关闭输入流

FileInputStream基本语法

构造方法

FileInputStream(String name);
FileInputStream(File file);

创建错误，throw IOException，因此，程序必须再try-catch语句中创建输入流