Java面向进阶（二）-CSDN博客

Java面向进阶

包

包就是文件夹，用来管理各种不同功能的Java类，方便后期代码维护。

包名规则：公司域名反写+包的作用，需要全部英文小写，见名知义。

简写：com.公司域名.作用（包名）

具体：com.公司域名.作用.类名（包名）+类名

包名加类名又叫全类名或全限定名

使用其他类的规则：

使用其他类时，需要使用全类名

导包前（复杂）：

public class Test{
    public static void main(String[] args){
        com.公司域名.作用.类名 变量 = new com.公司域名.作用.类名();
    }
}

import（导包）

导包后（简单）：

import com.公司域名.作用.类名；

public class Test{
    public static void main(String[] args){
        类名 变量 = new 类名();
}

Alt + Enter 自动导包

规则：

1、使用同一个包中的类时，不需要导包。

2、使用java.lang 包中的类时，不需要导包。

3、其他情况都需要导包。

4、如果同时使用两个包中的同名类，需要用全类名。

final关键字

final（最终）

方法

final修饰方法，表明该方法是最终方法，不能被重写。

class 父类{
    public final void 方法名(){
        ……
    }
}

class子类 extent 父类{
    @Override
    public void show(){  // 调用报错
    ……
    }
}
final修饰后，此父类的子类就不能在用父类中的方法，直接报错。

类

final修饰类，表明该类是最终类，不能被继承。

final class 父类{
    public void 方法名(){
    ……
    }
}

class 子类 extend 父类{  //报错
    ……
}
final修饰后，此父类将不能再被继承，变成了最终类。应用在当一个类中的所有方法都不想再被重写，就直接将整个类用final定义为最终类。

变量

final修饰变量，叫做常量，只能赋值一次

public static void main(String[] args){
    final int 变量 = 值;
    变量 = 任意值;// 不论何值都报错
}
final修饰后，一定赋有值，且只能赋值一次，此时的变量就已经可以等同于常量。

常量：

在实际开发，常量作为系统的配置信息，方便维护，提高可读性。

命名规则：

单个单词：全部大写

多个单词：全部大写，单词之间用下划线隔开

小细节：

final修饰的变量时基本类型：变量存储的数据值不能发生改变。

final修饰的变量时引用类型：变量存储的地址值不能发生改变，对象内部属性值可以改变。

权限修饰符

用来控制一个成员能够被访问的范围。

可以修饰成员变量、方法、构造方法、内部类。

权限修饰符的分类

有四种范围由小到大（private<空/缺省/默认<protected<public）

修饰符	同一个类	同一个包不同类	不同包的子类	不同包的无关类
private （私有）	true				私有的，只有自己能用
空（默认）	true	true			只有在本包中可用
protected （受保护的）	true	true	true		受保护的，其他包中的子也可用
public （公共的）	true	true	true	true	公共的，任意可用

使用规则

1、成员变量私有

2、公开方法

特例：若方法中的代码是抽取其他方法中共性代码，则此方法一般也私有

代码块

局部代码块

简单理解为一对花括号所包含的就是代码块，最内层的括号就是局部代码块

package Test3;
public class Test1 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);
    }//此时a已经从内存中消失
    System.out.println(a);//报错
}
在内存中变量，最内层局部代码块的括号中有变量a存在，当执行出最内层局部代码块时，同时变量a已从内存中走出，不再存在，所以报错。（已淘汰因为现在内存空间很大，以前内存空间小，不够用，现在完全够用）

构造代码块

写在成员位置的代码块就是构造代码块。

作用：可以把多个构造方法中重复的代码抽取出来。

执行时机：创建本类对象时，先执行构造代码块再执行构造方法

package Test3;
public class Test1 {
    private String name；
    private int age；
    {
        //构造代码块内容（原本方法中的内容）
    }
    public show(){//无参构造方法
        //重复内容
    }
    public show(String name,int age){//带参构造方法
        //重复内容
    }
    //省略get和set
}
运行时，先执行构造代码块，若构造方法中有其他内容，再执行构造方法中的内容。（渐渐也面临淘汰，不够灵活，可以用其他方式替代，像直接把重复代码放到一个方法中用this调用等多种灵活方法）

静态代码块

格式：static{}

特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发，只执行一次。

使用场景：在加载的时候，做一些数据初始化的时候使用。

package Test3;
public class Test1 {
    private String name；
    private int age；
    static{
        //静态代码块只执行一次
    }
    public show(){//无参构造方法
        //内容
    }
    public show(String name,int age){//带参构造方法
        //内容
    }
    //省略get和set
}

在程序最开始是给出一定的程序初始化。（小重点）

抽象类

抽象方法

将共性的行为（方法）抽取到父类；由于每个子类执行的内容是不一样的，所以，在父类中不能确定具体方法体。该方法就定义为抽象方法

抽象类的定义格式：

public abstract 返回值类型方法名（参数列表）；

抽象类

抽取共性时，无法确定方法体，就把方法定义为抽象的；强制让子类按照某种格式重写；如果一个类中存在抽象方法，那么该类就必须声明为抽象类

抽象方法的定义格式：public abstract class类名{}

注意事项：

1、抽象类不能实例化（不能创建对象）

2、抽象类不一定有抽象方法，有抽象方法的类一定是抽象方法

3、可以有构造方法

4、抽象类的子类（重写抽象类中的所有方法或本身就是抽象类）

接口

接口的定义和使用

1、接口用关键字interface来定义 public interface 接口名{}

2、接口不能实例化

3、接口和类之间是实现关系，通过implements关键字表示 public class 类名 implements 接口名 {}

4、接口的子类（实现类）重写接口中的所有抽象方法或本身就是抽象类

注：

1、接口和类的实现关系，可以单独实现，也可以多实现。

public class 类名 implements 接口名1，接口名2{}

2、实现类还可以在继承一个类的同时实现多个接口。

public class 类名 extends 父类 implements 接口名1，接口名2{}

接口中成员的特点

1、成员变量：只能是常量；默认修饰符（public static final）

2、构造方法：无（接口不能创建对象，不需要给子类成员赋值）

3、成员方法：只能是抽象方法；默认修饰符（public abstract）

接口和类之间的关系

类和类之间的关系

继承关系，只能单继承，不能多继承，但是可以多层继承

类和接口之间的关系

实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

接口和接口的关系

继承关系，可以单继承，也可以多继承

内部类

类的五大成员：属性，方法，构造方法，代码块，内部类

内部类：在一个类的内部再定义一个其他的类

使用时机：B类表示的事物时A类的一部分，且B类单独存在没有意义

内部类的分类

成员内部类、静态内部类、局部内部类、匿名内部类

成员内部类

写在成员位置的，属于外部类的成员

如何书写

成员内部类可以被一些修饰符所修饰，（private，默认，protected，public，static……）

在成员内部类里，JDK16之前不能定义静态变量，JDK16开始才可以定义静态变量。

public class Car{//外部类
    String carName；
    int carAge；
    int carColor；
    class Engine{//成员内部类
        String engineName；
        int engineAge；
    }
}

如何创建

法一：

在外部类中编写方法，对外提供内部类的对象。

package Test5;

public class Test {

    public static void main(String[] args) {
        /*
        编写成员内部类的注意点；
        1、成员内部类可以被一些修饰符所修饰，
        2、在成员内部类里面，JDK16之前不能定义静态变量，JDK16开始才可以定义静态变量
        获取成员内部类对象的两种方式：
        方式一：外部类编写方法，对外提供内部类对象（private）
        格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象；
         */

        //创建对象方式：
        Outer.Inner oi = new Outer().new Inner();//少用
    }
}

package Test5;

public class Outer {

    String name;


    class Inner{
        static int a = 10;
    }

}

法二：

直接创建格式：外部类名.内部类名对象名 = 外部类对象.内部类对象；

package Test5;

public class Test {

    public static void main(String[] args) {
        /*
        编写成员内部类的注意点；
        1、成员内部类可以被一些修饰符所修饰，
        2、在成员内部类里面，JDK16之前不能定义静态变量，JDK16开始才可以定义静态变量
        获取成员内部类对象的两种方式：
        方式二：直接创建
        格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象；
         */

        //当有private修饰外部类时（常用）
        Outer o = new Outer();
        o.getInstance();
        //因为name是一个成员变量，想要调用只能通过对象去调用
        //System.out.println(new Outer().name);

    }
}

package Test5;

public class Outer {

    String name;


    class Inner{
        static int a = 10;
    }

    public Inner getInstance(){
        return new Inner();
    }
}

如何获取外部类的成员变量

法一：当成员内部类被private修饰时，在外部类编写方法，对外提供内部类对象。

法二：当成员内部类被非私有修饰时，直接创建对象。

重名时：

System.out.println(Outer.this.变量名);

静态内部类、

静态内部类只能访问外部类中的静态方法和静态方法，如果想要访问非静态的需要创建对象

public class Car{
    String carName;
    int carAge;
    int carColor;
    static class English{
        String engineName;
        int engineAge;
    }
}

创建静态内部类对象的格式：外部类名.内部类名对象名 = new 外部类名.内部类名();

调用非静态方法的格式：先创建对象，用对象调用

调用静态方法的格式：外部类名.内部类名.方法名();