JAVA进阶学习02

一、JAVA中的包

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

1. 包名的命名规则：公司域名反写+包的作用（全部用英文小写，见名知意）
   如：com.java.domain
2. 类的全类名：包名+类名

com.java.domain.Student
com.java.domain.Student st = new com.java.domain.Student();

为了简化赋值操作可以用
import com.java.domain.Student
此时可以为：
Student st = new Student();

3. 导包的规则
   • java.lang包中的类可以直接使用不用导包
   • 同一个包中的类不用导包（一个包中通常包含多个class文件）
   • 两个包中的类同名需要使用全类名

二、final关键字

• final修饰类：该类称为最终类，特点是不能被继承
• final修饰方法：该方法称之为最终方法，特点是不能被重写。
• final修饰变量：该变量只能被赋值一次，即常量

2.1 final修饰方法

一般为规则型的方法作者不想让其他人修改覆盖会用final修饰

2.2 final修饰类

可见该父类无法继承

2.3 final修饰变量

• final修饰数值型变量：其数值不能改变
• final修饰引用型变量：其变量存储的地址不能发生改变，但若存储对象内部的属性值可以修改

该方法一般用作定义常量，用于系统的配置信息，如圆周率

---

常量的定义：

public class Constant {
    //常量定义的一般格式
    //为了方便在其他类中被访问所以一般还会加上public修饰符
    //常量命名规范：建议都采用大写字母命名，多个单词之前有“_”隔开
    public static final String NEW_NAME = "张三";
}

三、类中成员权限修饰符

共有四种权限大小
private>空着>protected>public

修饰符	同一个类中	同一个包中其他类	不同包下的子类	不同包下的无关类
private	✔
为空	✔	✔
protected	✔	✔	✔
publlic	✔	✔	✔	✔

一般最常用的就是private和public

四、代码块

4.1 代码块

用{}括起来的一段代码，在其中定义的变量，方法其生命周期伴随值花括号的结束而结束

4.2 构造代码块

在类的定义中，定义在变量之后，构造方法之前。一旦创建该类的对象此段代码就会执行。（现已不常用）

4.3 静态代码块

通过static关键字修饰，随着类的加载而加载，自动触发无需调用，且只执行一次。
主要用于数据初始化，第一次使用该类时就执行本块内容之后再用本类将不再执行；
或者写在方法内，方法第一次被调用将会执行该代码块，之后调用不再执行。

格式：

static{
···
};

代码块的调用优先于类的构造器，随着类的加载而运行

五、抽象类

5.1 初识抽象类

java中的抽象用abstract修饰：

• 被abstract修饰的类，就是抽象类
• 被abstract修饰的方法，就是抽象方法（不允许有方法体）

5.2 抽象类的定义

public abstract class Student {
    //成员变量
    private String name;
    static String schoolName;

    //构造方法
    public Student(){

    }

    //抽象方法
    public abstract void test(); //没有代码块定义

    //实例方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

注意：

1. 若类中存在抽象方法必须申明为抽象类，但抽象类中不一定有抽象方法，且抽象类中可以含有普通方法
2. 抽象类不能创建对象
3. 抽象类一般用作子类继承，且继承后必须重写所有抽象方法
4. 抽象方法不能是私有的，为了方便子类的重写

子类继承父类如果不重写父类的抽象方法，要想不出错，这个子类也必须是抽象类

//B类基础A类，此时B类也是抽象类，这个时候就可以不重写A类的抽象方法
public abstract class B extends A {

}

快捷键：子类继承抽象类时重写抽象方法
在报错的红线处 Alt +Entter

---

抽象类中构造方法的作用：
用于子类在创建对象时对抽象类中成员变量的初始化

5.3 抽象类的作用

1. 用抽象类可以把父类中相同的代码，包括方法声明都抽取到父类，这样能更好的支持多态，提高代码的灵活性。

2. 反过来用，我们不知道系统未来具体的业务实现时，我们可以先定义抽象类，将来让子类去实现，以方便系统的扩展。

3. 当一个项目由多个人开发时为了便于规范代码的书写，用抽象类统一方法的格式（名称，返回值等）

六、接口

6.1 初识接口

在子类抽离出父类的过程中，有部分共性的方法是无法抽离的，或者其他类的对象有相同的动作，此时为了规范方法的声明要使用接口。
多个类之间的公共规范

例如动物案例中的游泳技能，既有会游泳的也有不会的，为每个会游泳的动物写一个游泳方法可能会使游泳方法不规范（例如命名不规范），还有“人”也可以拥有该游泳的技能，但人不属于动物类（类之间的协调）

即接口是一种规则，是对行为的抽象

6.2 接口的定义

接口在IDEA的创建：
同类的定义，采用大驼峰命名

Java提供了一个关键字interface，用这个关键字来定义接口这种特殊结构。格式如下:

public interface 接口名{
    //成员变量（常量）
    //成员方法（抽象方法）
}

//如下，类似于类的定义，但关键字不同
public interface AnimalAction{
    //这里public static final可以加，可以不加，为默认修饰。
    public static final String swiming = "泳姿";
    
    //这里的public abstract可以加，可以不加，为默认修饰。
    public abstract void swim();
}

//测试接口
public class Test{
    public static void main(String[] args){
        //打印A接口中的常量
        System.out.println(A.swiming
        );
        
        //接口是不能创建对象的，即不可被实例化
        A a = new A(); //报错
    }
}

---

类对接口的实现：

//格式：
public class 类名 implements 接口1,接口2{

}

//具体示例
public interface AnimalAction{
    //这里public static final可以加，可以不加。
    public static final String swiming = "泳姿";
    
    //这里的public abstract可以加，可以不加。
    public abstract void swim();
}

public class Frog extends Animal implements AnimalAction{
	//青蛙类构造方法略

	//接口的重写
	@Override
	public void swim(){
		System.out.println("青蛙的"+swiming+"是 蛙泳");
	}
}

注意：当实现多个接口时，接口中的方法重名，只用重写一次即可

6.3 接口中的成员

• 成员变量：只能是静态常量
  默认修饰符：public static final
  通常用：接口名.变量名来调用接口
• 构造方法：没有
• 成员方法：只能是抽象方法
  默认修饰符：public abstract
  JDK8:可以定义有方法体的方法
  JDK9：可以定义私有方法

6.4 接口之间的关系

一个接口可以继承一个或多个接口

interface A{
    void test1();
}
interface B{
    void test2();
}
interface C{}

//比如：D接口继承C、B、A
interface D extends C, B, A{

}

//E类在实现D接口时，必须重写D接口、以及其父类中的“所有”抽象方法。
class E implements D{
    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }
}

6.5 接口JDK8的新特性

public interface A {
    /**
     * 1、默认方法：默认方法用于接口升级使用，后期接口更新时，不是所有的方法都有用，所以没必要全部重写
     * 使用defaul替换abstract修饰，默认会被public修饰
     * 实例方法：对象的方法，必须使用实现类的对象来访问。
     */
    default void test(){
        System.out.println("===默认方法=="); //默认方法可以含有方法体
        
    }
	默认方法不是抽象方法，不强制被重写，一旦重写就不能加default
	如果实现了多个接口，但接口中的默认方法重名，就必须要重写该方法。
   
    /**

     * 2、静态方法：使用static替换abstract修饰，且默认会被public修饰
     */
     publid static void test(){
        System.out.println("==静态方法==");
     }
	 静态方法不用重写，因子类未继承接口的非虚方法
	 且子类中的方法可以与接口中的静态方法同名
	 子类在使用时可以直接用接口名调用
	/**
     * 3、私有方法：必须使用private修饰。(JDK 9开始才支持的)
     * 私有方法为解决默认方法之间方法重复的问题，例如两个默认方法中可能同时包含show方法，此时可以抽取出来供接口的内部调用	
     * 实例方法：对象的方法。
     */
    private void test(){
        System.out.println("===私有方法==");
    }
    private static void test(){
        System.out.println("===私有方法==");
    }

    /**

抽象方法(abstract修饰)：需要被实现类重写，通过实现类的对象调用
默认方法(default修饰)：用于非强制实现类重写的方法
静态方法(static修饰)：可以直接通过接口名调用，不用实例化
私有方法(private修饰)：用于接口中公共方法的抽象，仅供接口内部使用

IDEA快捷键：直接在类中书写需要重写的函数名，会有提示

6.6 接口与抽象类的区别

1. 抽象类可以包含普通字段和成员，接口中不能包含普通方法，子类必须重写所有的抽象方法
2. 二者的职责不同：抽象类是为了代码的复用，接口时为了定义规范（如函数名称的统一，如吃可以写作eat,taste,peck等，此时需要统一名称）
3. 使用extends继承抽象类，使用implements关键字实现接口
4. 一个子类只能继承一个抽象类，一个子类可以实现多个接口
5. 一个接口可以继承多个接口