JAVA基础知识点10-Package 与 import、Javabean、面向对象的三大特性、重写与重载的区别、final、super关键字this之间的区别、Object 老祖宗类

Package  与  import
Package:
    包: 相当于系统中的文件夹
    作用:
        1.管理众多的java资源
        2.提供多重命名空间
    包信息 : 存在java类的首行
    定义规范: 全部 小写,每个层级之间使用.分隔
            公司域名倒着写.功能名字|模块名字

import:
    想要在A类中使用B类,(创建B类的对象,调用B类中的静态内容)
    不需要导包的类:
        1.同包下的
        2.java.lang包下的内容(String,System)
    想要使用其他包下的类,非lang包下的内容,需要指明类的位置,需要导包 :
        1.使用的时候直接指明类的位置,使用一次需要指明一次,比较麻烦
        2.import 导包
            指明当前类中使用的某个类型的位置
            位置: 类的尚明
            语法: import 包名.类名;
        3.如果使用了某一个包下的多个类,可以一个一个导入,可以一起导入:
            模糊匹配: * 模糊匹配某一个包下的多个类
            import java.util.*;
            优点: 方便
            缺点: 降低编译效率,不会降低运行效率
        4.静态导入
            只导入一个类中的某个静态内容
            import static

Javabean:
    泛指一些列的模板类,是一系列的统称
    模板类|javabean|实体类|pojo...

Javabean的开发规范:
    1.类是公共的
    2.至少提供一个空构造,可选择的提供带参构造
    3.属性私有化
    4.提供公共的访问方式  setter  getter
    5.重写toString

 

面向对象的三大特性:  继承
                    封装: 隐藏内部的实现细节,对外提供公共的访问方式


实现类的层面的封装,抽象
定义父类-->抽取子类中共性的内容
定义javabean--> 对一系列事物的共性的抽象,抽出像的部分

继承: 子承父业
    extends关键字实现继承
    子类 extends 父类

作用:
    提高代码的复用性

    子类一旦继承父类,就有权使用父类中的内容
    子类可以继承, extends 扩展,可以定义子类中独有的内容
    继承是单继承机制,一个子类只能继承一个父类,多实现
    一个父类可以存在多个子类

单继承的优点:
    简单
单继承的缺点 :
    不便于后期维护

父类|超类|基类: 被继承的类
子类|派生类 : 继承父类的类

 

重写 与 重载的区别
    都是方法的特性

 重载:
    1.同一个类中的多个方法
    2.方法名相同
    3.参数列表不同|方法签名不同

 重写:
    1.不同的类
    2.继承|实现
    3.方法签名相同

 方法的重写: 方法体的重新实现

 需求前提:
    从父类中继承的功能想要,但是实现方式不想要,定义子类独有的对于这个功能的实现,通过方法的重写实现

 注意:
    子类对象调用成员的时候,如果子类中有,就就近原则找子类的,子类没有找父类的
    当子类中存在方法的重写,子类对象会调用子类中重写的方法,子类没有找父类

 不能重写的方法:
        1.被private修饰的方法不能被重写
        2.被final修饰的额方法不能被重写
        3.被static修饰的方法 不能被重写
            并且如果子类中出现于父类静态方法同名的方法,要求也是静态的

 检查重写的方式:
    1.在行号的位置显示o箭头指向被重写的方法
    2.在重写方法的上面添加一个@Override 强制检查此方法是否为一个重写方法,不是报错

 重写的三个条件:
    1.== 子类重写方法与父类中的被重写方法 方法签名要求完全相等
    2.<= 如果子类重写方法与父类中的被重写方法 返回值类型是基本数据类型,要求完全相等,引用数据类型,子类<=父类
    3.>= 子类重写方法的权限修饰符>=父类中被重写方法的权限修饰符

 

修饰符:

访问权限修饰符 : 修饰成员被访问的权限,不能修饰局部-->成员修饰符

	本类中(自己)	同包类(家人)	不同包下的子类(私生子)	不同包下的其他类(陌生人)
private私有的	√
default默认的	√	√
protected受保护的	√	√	√
public公共的	√	√	√	√

注意:
        能够修饰类的public,default(默认省略)
        在不同包下的子类中,通过继承关系才能使用受保护的成员

 

final: 最终的
    可以修饰局部可以修饰成员
    1.被final修饰的变量为常量(标识符的规范)
    2.被final修饰的方法不能被重写
    3.被final修饰的类不能被继承(太监类)

    一个自定义的引用数据类型可以作为 一个类的成员类型

 

super 关键字  this 之间的区别:
    this关键字用来指代当前对象(new)
    构造器首行调用奔雷中的其他构造器  this(参数)
    区分同名变量问题  局部与成员

    super
        指代父类对象

        在子类构造器的首行通过super(参数)调用父类的构造器
        区分同名问题
            如果子类与父类存在同名情况(成员),在子类中默认就近原则找子类的,如果想要找父类中的同名成员,使用super.调用
            如果子类中存在局部与成员同名情况,默认找局部,想要指代成员通过this.调用
            如果没有同名问题,this.和super.都可以省略


        如果子类构造器中没有显示调用父类的指定构造器,默认调用父类空构造super()
        在一个构造器的首行,this()与super()不能同时存在
        当存在子父类继承关系下,创建子类对象-->先父类后子类
        this和super不能使用在static环境中

 

public class SuperDemo {
    public static void main(String[] args) {
        Zi zi = new Zi("我是子类");

        System.out.println(zi.nameZi);
        System.out.println(zi.nameFu);

        //System.out.println(zi.age);
        zi.test();
    }
}

class Fu{
    String nameFu = "父类";
    //子父类同名的成员变量age
    int age = 50;

    public Fu(){
        System.out.println("这个是父类空构造");
    }

    public Fu(String name) {
        this();
        this.nameFu = name;
        System.out.println("这个是父类带参构造");
    }
}

class Zi extends Fu{
    String nameZi = "子类";
    int age = 20;

    public Zi(){
        super("我是父类");
        System.out.println("这个是子类空构造");
    }

    public Zi(String name) {
        //super()
        this();
        this.nameZi = name;
        System.out.println("这个是子类带参构造");
    }

    public void test(){
        int age = 100;
        //同名问题: 子类的成员变量age 与 父类的成员变量age同名啦
        System.out.println(age);        //默认就近原则
        System.out.println(this.age);   //子类中成员
        System.out.println(super.age);  //父类中的成员
    }
}

 运行截图：

Object 老祖宗类
    是所有类的父类
    java中的所有类都会直接或者间接的继承自Object

    Object类中定义的成员,只要子类有权限访问都能使用

    Object中的重点常用方法:
        1.equals
            比较两个对象是否相等
            认为: 比较引用数据类型的对象数据的时候,不应该比较对象地址,应该 比较对象内容(成员变量的值)-->重写equals方法,想怎么比较就怎么写
            ==比较对象的地址值
            Object类中的equals方法 ,也是默认比较对象地址
                public boolean equals(Object obj) {
                    return (this == obj);
                }


        2.toString()
            可以将对象以字符串的形式返回
            当打印一个对象的引用时候,默认打印的是当前对象调用了toString()的返回值

            当打印一个对象的引用时候,想要得到一个对象的基本信息|成员变量的值-->可以在子类中重写toString,让它打印成员变量非地址
            子类中不重写打印对象地址,子类重写,想打印就写什么

 

public class ObjectDemo {
    public static void main(String[] args) {
        User u = new User("张三","123");
        User u2 = new User("李四","456");
        User u3 = new User("李四","456");
        System.out.println(u2);
        System.out.println(u3);


        //比较对象地址
        System.out.println(u2==u3);
        System.out.println(u2.equals(u3));
    }
}

class User{
    private String name;
    private String pwd;

    public User() {
    }

    public User(String name, String pwd) {
        this.name = name;
        this.pwd = pwd;
    }

    //重写方法
    @Override
    public String toString() {
        return name+"-->"+pwd;
    }

    @Override
    public boolean equals(Object obj) {  //Object obj = u3;
        //增强程序健壮性  先过滤一下如果地址相等,就是一个对象,不需要比较内容
        if(this==obj){
            return true;
        }

        //先把obj从Object类型强转为User类型,因为想要调用 user的成员变量name
        User other = (User)obj;  //other就是参数对象  User other = u3;
        //如果用户名相等比较用户密码,如果用户名不相等,直接返回false
        if(this.name.equals(other.name) ){
            return this.pwd.equals(other.pwd);
        }
        return false;
    }
}

运行截图：