面向对象（三）

package与import

java引入了包机制

    包信息存在与java代码的第一行,类的上面
    包的定义规范 : com.yjxxt.xxxx
    标识符规范 : 全部小写

作用:

        1)方便管理众多资源
        2)引入多重命名空间

导包 :

    指明要使用的资源所在的位置

    1)使用的位置使用权限定名java.util.Scanner,只在当前位置有效
    2)使用import导包,在类的上面,package信息的下面,一个Java文件所有类有效
    3)*模糊导入,模糊匹配当前包下的所有类,会降低编译效率,不会降低运行效率
    4)静态导入只导入静态内容   import static

不需要导包的类 :

            java.lamg
            同包下的类

安全隐患问题 :
属性赋值,值有可能出现符合类型范围要求但是不符合业务要求的数据

private 私有的

    被private关键字修饰的内容只能在本类中使用,其他类中无法使用

私有属性需要配合提供一对公共的访问方式–> 方法,因为在方法中可以做逻辑判断

    设置器 setter : 为私有属性设置值
    访问器 getter : 获取私有属性

注意:

 定义实体类时属性都需要私有化,并且提供一对公共的访问方式

封装 :

隐藏内部的实现细节,对外提供公共的访问方式

优点 :

        提高程序的安全性
        提高代码的复用性

私有是封装,封装是私有?

    私有是封装 √
    封装是私有 ×
    方法,类,属性的私有化... 都是封装的体现

继承 :

子承父业

目的 :

提高代码的复用性

作用:

 子类一旦继承父类,有权使用父类中的成员,可以在子类中定义子类独有的内容

定义:

 子类  extends  父类

实体类|子类 :

 根据一系列对象抽取共性所定义的实体类

父类 :

子类的共性

子类| 派生类
父类 | 基类 | 超类

特点 :

单继承机制 ,一个子类只能继承一个父类,但是一个父类可以存在多个子类
修饰类只能使用public|default(默认)
开闭原则--> 面试对象设计原则之一  : 对修改关闭,对扩展开放

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

代码：

练习 : 定义猫,狗类,分析通过继承结果实现
public class Class001_Extends {
    public static void main(String[] args) {
        Teacher t = new Teacher();
        t.name = "马云";
        t.age = 50;
        t.subject = "英语";
        t.teach();
        t.sleep();
    }
}

//父类
class Person{
    public String name;
    public int age;

    public void sleep(){
        System.out.println(name+"在休息");
    }
}

//子类
class Teacher extends Person{
    public String subject;  //教授学科

    //构造器
    public Teacher(){

    }
    public void teach(){
        System.out.println("教书育人!!!");
    }
}
//子类
class Student extends Person{
    public int num;  //学号

    //构造器
    public Student(){

    }

    public void study(){
        System.out.println("学习!!!");
    }
}

访问权限修饰符 :

                                 本类                     同包类                      不同包下的类                      不同包下的其他类
    private私有的                  √
    default默认的                  √                        √
    protected受保护的          √                        √                            √
    public公共的                   √                        √                            √                                  √

注意:

    都是成员修饰符,只能修饰成员,不能修饰局部
    能够修饰类的 : public | default
    Protected修饰的成员在不同包下的子类中,需要通过继承关系使用
    最常用的两种权限 : public|private

思考 : 父类中私有的成员,子类能够是否,能否继承?

代码：

public class Class001_Modifier {
   public String  testPublic = "public";
   protected String  testProtected = "protected";
   String  testDefault = "default";
   private String  testPrivate = "private";

    public static void main(String[] args) {
        //测试本类中使用
        Class001_Modifier cm = new Class001_Modifier();
        System.out.println(cm.testPublic);
        System.out.println(cm.testProtected);
        System.out.println(cm.testDefault);
        System.out.println(cm.testPrivate);
    }

   public void test(){
       //测试本类中使用
       System.out.println(testPublic);
       System.out.println(testProtected);
       System.out.println(testDefault);
       System.out.println(testPrivate);
   }

}
//同包类
class Demo{
    public static void main(String[] args) {
        //测试本类中使用
        Class001_Modifier cm = new Class001_Modifier();
        System.out.println(cm.testPublic);
        System.out.println(cm.testProtected);
        System.out.println(cm.testDefault);
        //System.out.println(cm.testPrivate);
    }
}

super

super 与 this 之间的区别:

    this 指代当前new对象
        本类构造器的首行调用本类中的其他构造器this(参数列表)
        区分局部与成员同名问题
            默认就近原则
            通过this.调用成员

    super 指代父类对象
        子类构造器的首行,通过super(参数)调用父类中的指定构造器
            如果没有显示通过super(参数)调用,默认调用父类的空构造
        区分子父类中同名成员
            如果不存在同名问题 : 可以省略super.调用父类成员
            如果存在子父类同名成员问题,同名局部问题 :
                默认就近原则
                有局部找局部
                通过this.找子类成员
                通过super.找父类成员

注意:

    子父类继承关系下 : 创建子类对象的时候,其实会先父类后子类
    不能在构造器的首行同时使用this(参数)与super(参数)
    this与super都不能使用在静态方法中

代码：

public class Class001_Super {
    public static void main(String[] args) {
        Zi zi = new Zi("");
        zi.test();
    }
}

class Fu{
    String str = "FuStr";
    public Fu(){
        System.out.println("Fu");
    }
    public Fu(int i){
        System.out.println("Fu");
    }
}

class Zi extends Fu{
    //String str = "ZiStr";
    public Zi(){
        super(100);
        //super();
        System.out.println("Zi");
    }
    public Zi(String s){
        this();
        System.out.println("Zi----String");
    }

    public void test(){
        String str = "local";
        System.out.println(super.str);
    }
}

重写Override

重写 与 重载 之间的区别 :

    都是方法的特性

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

    重写的实现条件:
        1.两个类
        2.继承|实现
        3.方法签名完全相同

重写的需求 :

当子类从父类中继承的功能满意,对功能实现不满意的时候,可以在子类对从父类中继承的功能重新实现

调用使用 :

    如果子类中没有重写,调用父类的,父类没有报错
    如果子类存在重写方法,调用子类中重写后的方法,对父类的方法进行屏蔽

检测是否为重写方法 :

    1.idea行号后面的位置出现o向上箭头
    2.在重写方法上添加注解 @Override

不能被重写的方法 :

    1.被private修饰的方法不能被重写
        能被子类继承,但是无权使用
    2.被final修饰的方法不能被重写
    3.被static修饰的方法不能被重写
        可以被继承不能被重写
        如果子类中出现与父类中静态方法同名的方法,要求子类中这个同名的方法也被static修饰

代码：

public class Class001_Override {
    public static void main(String[] args) {
        SiCong siCong = new SiCong();
        siCong.words();
        siCong.test();
    }
}

class JianLin{
    String name = "王健林";

    //名人名言
    public static void words(){
        System.out.println("先定义小目标,挣它一个亿...");
    }

    public static void test(){}
}

class SiCong extends JianLin{
    String name = "王思聪";

    //重写方法
    public static void words(){
        System.out.println("我在不在乎我的朋友有钱没有,反正都没我有钱...");
    }
}

final

final 最终的
    被final修饰的变量为常量
    被final修饰的方法不能被重写
    被final修饰的类不能被继承-->太监类

Javabean

  Javabean :  一系列实体类的统称
        定义规范 :
            1.类是公共的
            2.至少一个空构造
            3.属性私有化
            4.提供一对公共的访问方式