JAVA教程 从入门到精通 Day9

4.11 包 package

机制：

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

作用：

• 方便管理众多资源
• 引入多重命名空间

导包：

• 导包指明要使用的资源的所在位置
  • 使用的位置 使用权限定名java.until.Scanner 只在当前位置有效
  • 使用import导包 在类的上面 package信息的下面 一个java文件中所有类中有效
  • *模糊导入 模糊匹配当前包下的所有类 会降低编译效率 不会降低运行效率
  • 静态导入只导入静态内容 import static
    • import static java.lang.Math.PI; (3.1415926……)
    • import static java.lang.Math.round; (四舍五入)
• 不需要导包的类 ：
  • java.lang
  • 同包下的类

范例：
package com;

import java.util.Random;
import java.util.Scanner;
//这两个就可以实现模糊导包 import java.util.*
import static java.lang.Math.PI;
import static java.lang.Math.round;

public class Test {
    public static void main(String[] args) {
        //权限定名
        java.util.Scanner sc=new java.util.Scanner(System.in);
        Scanner sa=new Scanner(System.in);
        Random sb=new Random();

        //静态变量
        System.out.println(PI);
        System.out.println(PI);
        System.out.println(PI);

        System.out.println(round(3.5));
        System.out.println(round(4.5));

        //静态方法
        System.out.println();
    }
}

class Demo{
    public static void main(String[] args) {
        //权限定名
        java.util.Scanner sc=new java.util.Scanner(System.in);
        Scanner sa=new Scanner(System.in); // 同一个包中就可以不在导包
        Random sb=new Random();
    }
}

4.11 Private 关键字

public修饰的内容可能存在安全隐患问题：

属性赋值 值可能出现符合类型范围要求但是不符合业务要求的数据

private 私有的

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

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

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

注意：

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

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

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

    public String getName(){
        return name;
    }

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

    public int getAge(){
        return age;
    }

    public void show(){
        System.out.println(name+"===>"+age);
    }
}

public class TDemo {
    public static void main(String[] args) {
        T sc=new T();
        sc.setAge(18);
        sc.setName("汪超");
        sc.show();
        System.out.println(sc.getAge()+","+sc.getName());
    }
}

5.12 封装

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

优点：

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

私有是封装 √

封装是私有 ×

方法、类、属性的私有化……都是封装的体现

5.13 继承

**继承：**子继父业

• **目的：**提高代码的复用性
• **作用：**子类一旦继承了父类 有权使用父类的成员 可以在子类中定义子类独有的内容
• **定义：**子类 extends 父类

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

**父类：**子类的共性

子类|派生类

父类|基类|超类

特点：

• 单继承机制 一个子类只能继承一个父类 但是一个父类可以存在多个子类
• 修饰符只能使用public | default（默认） 修饰
• 开闭原则===>面向对象设计原则之一：对修改关闭 对扩展开放

**单继承的优点：**简单

**单继承的缺点：**不便于后期维护

class Person {
    String name;
    int age;

    public void sleep(){
        System.out.println("好好休息！！！");
    }
}


class Student extends Person {
    String id;

    public void study(){
        System.out.println(name+"好好学习！！！");
    }
}

class Teacher extends Person {
    String subject;

    public void teacher(){
        System.out.println(name+"教书育人！！！");
    }
}

public class Demo {
    public static void main(String[] args) {
        Student sc=new Student();
        sc.name="汪超";
        sc.age=18;
        sc.study();
        sc.sleep();

        Teacher ss=new Teacher();
        ss.name="胡歌";
        ss.age=39;
        ss.teacher();
        ss.sleep();
    }
}

5.14 访问权限修饰符

权限修饰符	本类	同包类	不同包下的子类	不同包下的其他类
private 私有的	√
default 默认的	√	√
protected 受保护的	√	√	√
public 公共的	√	√	√	√

注意：

• 都是成员修饰符 只能修饰成员 不能修饰局部
• protected修饰的成员在不同包下的子类中 需要通过继承关系使用 使用子类对象
• 常见的两种权限：public | private
• 父类中私有的成员 子类不能用 (如：父亲的私房钱儿子不可以使用)

package wang01;

public class Modifier {
    public String testPublic="public";
    protected String testProtested="protected";
    String testDefault ="default";
    private String testPrivate="private";

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

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

//同包类
class Demo{
    public static void main(String[] args) {
        Modifier sc=new Modifier();
        System.out.println(sc.testPublic);
        System.out.println(sc.testProtested);
        System.out.println(sc.testDefault);
        // System.out.println(sc.testPrivate);
    }
}

package wang;

import wang01.Modifier;

//不同包下的子类
public class Modifier01 extends Modifier {
    public void test() {
        System.out.println(testPublic);
        System.out.println(testProtested);
//        System.out.println(testDefault);
//        System.out.println(testPrivate);
    }

    public static void main(String[] args) {
        //父类对象访问
        Modifier sc=new Modifier();
        System.out.println(sc.testPublic);
        //在不同包下的子类中 需要通过继承关系使用
//        System.out.println(sc.testProtested);
//        System.out.println(sc.testDefault);
//        System.out.println(sc.testPrivate);

        //子类对象访问
        Modifier01 ss=new Modifier01();
        System.out.println(ss.testPublic);
        System.out.println(ss.testProtested);
//        System.out.println(ss.testDefault);
//        System.out.println(ss.testPrivate);
    }
}

package wang;

import wang01.Modifier;

//不同包下的其他类
public class Others {
    public static void main(String[] args) {
        Modifier sc=new Modifier();
        System.out.println(sc.testPublic);
//        System.out.println(sc.testProtested);
//        System.out.println(sc.testDefault);
//        System.out.println(sc.testPrivate);
    }
}

5.15 Super 关键字

super与this 之间的区别:

• this指代当前new对象

  • 本类构造器的首行调用本类中的其他构造器this(参数列表)

  • 区分局部与成员同名问题

    • 默认就近原则

    • 通过this.调用成员

• super指代父类对象

  • 子类构造器的首行 通过super(参数)调用父类中的指定构造器
    • 如果没有显示通过super(参数)调用 默认调用父类的空构造
  • 区分子父类中同名成员

• 如果不存在同名问题:可以省略super.调用父类成员

  • 如果存在子父类同名成员问题,同名局部问题:|

    • 默认就近原则

    • 有局部找局部

    • 通过this.找子类成员

    • 通过super.找父类成员

注意:

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

package wang01;

public class TestSuper {
    public static void main(String[] args) {
        Zi sc=new Zi();
    }
}

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

class Zi extends Fu{
    String str="fff";
    public Zi(){
        super(10);
        System.out.println("Zi");
        System.out.println(super.str);
    }
    public Zi(String s){
        System.out.println("zizi");
    }
}