Java 面向对象进阶（二）

​
​

活动地址：CSDN21天学习挑战赛

目录

• 一、包
• • 1、什么是包？
  • 2、包的语法
  • 3、包的作用
• 二、权限修饰符
• 三、final
• • 1、final作用
  • 2、final注意事项
• 四、常量
• • 1、概述和基本作用
  • 2、常量做配置信息原理和优势
  • 3、常量做信息标志和分类
• 五、枚举
• • 1、枚举概述
  • 2、定义格式
  • 3、枚举特征
• 六、抽象类
• • 1、抽象类概念
  • 2、注意事项
  • 3、使用场景
  • 4、final和abstract关系
  • 5、模板方法
• 七、多态
• • 1、多态概念
  • 2、成员访问特点
  • 3、多态前提
  • 4、优势
  • 5、类型转换

一、包 1、什么是包？

• 为了方便管理组织java文件的目录结构，并防止不同java文件之间发生命名冲突而存在的一个java特性

2、包的语法

• 格式：package 公司域名倒写.技术名称 建议小写

package com.alibaba.fastjson.api;

• 导包

相同包下的类可以直接访问，不同包下的类必须导包才能正常使用。格式：import 报名.类名
假如一个类需要用到不同类，两个类名相同，默认只能导入一个类，另一个类需要带包名访问

import java.lang.String;

3、包的作用

1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
2、如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
Java 使用包(package)这种机制是为了防止命名冲突，访问控制，提供搜索和定位类(class)、接口、枚举(enumerations)和注释(annotation)等。

二、权限修饰符

• 权限修饰符：是用来控制一个成员能够被访问的范围
• 可以修饰成员变量、方法、构造器、内部类、不同权限修饰符能被访问的范围也不同
• 权限修饰符作用范围：范围有小到大排列(private>>缺省>>protected>>public)
  

三、final 1、final作用

• final关键字最终的意思，可以修饰(类、方法、变量)
• 修饰类：该类是最终类，不能被继承
• 修饰方法：该方法是最终方法，不能被重写
• 修饰变量：第一次赋值后，不能被再次赋值(有且只能赋值一次)

2、final注意事项

• final修饰基本类型变量：变量存储数据值不能变
• final修饰引用类型变量：变量存储的地址值不能变，指向的对象内容可以发送改变

四、常量 1、概述和基本作用

• 常量是使用public static final 修饰成员变量，必须有初始化值，执行过程值不能被改变。
• 常量命名规范：英文单词全部大写，连接用_
• 常量作用：记录系统配置数据
  

public final class Season {
    public static final String SPRING = "春天";
    public static final String SUMMER = "夏天";
    public static final String AUTUMN = "秋天";
    public static final String WINTER = "冬天";

    public static void main(String[] args) {
        System.out.println(SPRING);
        System.out.println(SUMMER);
        System.out.println(AUTUMN);
        System.out.println(WINTER);
    }
}

2、常量做配置信息原理和优势

• 在编译阶段会进行“宏替换”：把使用常量的地方替换成真实的字面量
• 系统易维护、可读性好

3、常量做信息标志和分类

• 代码可读性好，实现了软编码形式

五、枚举 1、枚举概述

• 枚举是Java中特殊类型
  枚举作用：为了做信息的标志和分类

2、定义格式

enum 枚举名{ 枚举值表 };

enum Season {
    SPRING, SUMMER, AUTUMN, WINTER;
}

3、枚举特征

• 枚举类都继承了枚举类型，java.lang.Enum
• 枚举都是最终形式，不可被继承
• 构造器是私有的，枚举对外不能创建对象
• 枚举类的第一行默认都是罗列枚举对象的名称
• 枚举类相当于多例模式

六、抽象类 1、抽象类概念

• Java中abstract是抽象的意思，可以修饰类、成员方法
• abstract修饰类，这个类是抽象类；修饰方法，这个方法是抽象方法

修饰符 absctract class 类名{
	修饰符 abstract 返回值类型 方法名称(形参列表)
}

public abstract class Person {
    public abstract String Sing();
}

2、注意事项

• 抽象方法只有方法签名，不能声明方法体
• 一个类中如果定义了抽象方法，这个类必须声明成抽象类
• abstract 不可以和static、virtual、final、native一起使用
• 类有的成员(成员变量、方法、构造器)抽象类都具备
• 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
• 一个继承了抽象类必须重写抽象类的全部抽象方法，否则这个类也需要定义为抽象类
• 不能用abstract修饰变量、代码块、构造器
• 特征：得到了抽象方法，失去了创造对象的能力

3、使用场景

• 抽象类一般作为父类，让子类继承

public abstract class Person {
    public abstract void Sing();
}

4、final和abstract关系

• 互斥关系
• abstract定义抽象类作为模板让子类继承，final定义类禁止被继承
• 抽象方法定义功能让子类重写，final定义的方法不能被重写

5、模板方法

• 场景

当系统中出现同一个功能，多处开发，功能代码基本相同，部分不同
-模板实现步骤
定义一个抽象类
定义2个方法，一个是模板方法，把相同代码封装好，不同代码定义成抽象方法
子类继承抽象方法，重写抽象方法

• 模板方法推荐final修饰

模板方法直接让子类使用，防止子类重写模板方法，更安全、专业

• 模板方法解决了什么问题？

提高代码复用性
定义通用结构，不能确定的方法定义成抽象方法，交由子类重写

七、多态 1、多态概念

指对象有多种形态
定义：

父类类型 对象名称 = new 子类构造器;

Person person = new Student();

2、成员访问特点

• 方法调用：编译看左边，运行看右边
• 变量调用：编译看左边，运行看左边

3、多态前提

• 有继承/实现关系
• 有父类引用指向子类
• 有方法重写(多态侧重行为多态)

4、优势

• 在多态形势下，右边对象可以实现解耦合，便于扩展和维护
• 定义方法时，使用父类型作为参数，该方法就可以接收这父类的一切子类对象，体现出多态的扩展性和便利

Person person = new Student();
person.eat("吃饭。。。。");

• 多态产生问题

多态下不能使用子类的独有功能

5、类型转换

• 自动类型转换(从子到父)：Person person = new Student();
• 强制类型转换(从父到子)：

从父到子(必须强制类型转换)：子类 变量 = (子类)(父类类型变量)
作用：可以解决多态下的优势，实现调用子类的独有功能
注意：有继承/实现关系的类可以在编译阶段进行类型强制转换；如果转型后的类型和真实对象的类型不同，报：ClassCastException错误

Student a = (Student)b;// 出现异常 ClassCastException

• 建议：强转前用instanceof判断当前对象真实类型

变量名 instanceof 真实类型
判断类型是否一致，是返回true，否则返回false

public class Person {
    private String name;
    private int age;

    public void eat(){
        System.out.println("人天生就会吃");
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }
}

public class Teacher extends Person{
    private String ClassName;

    public void teacherCourse(){
        System.out.println("老师必须要会授课");
    }

    public String getClassName() {
        return ClassName;
    }

    public void setClassName(String className) {
        ClassName = className;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "ClassName='" + ClassName + ''' +
                '}';
    }
}

public class Season {
    public static void main(String[] args) {
        Person person = new Teacher();
        if(person instanceof Teacher){
            System.out.println(true);
        }
    }
}