Java第七天

包

包的本质分析

包的本质 实际上就是创建不同的文件夹来保存类文件
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dUKyUYQ7-1645795496832)(C:\Users\xiaban\Pictures\java学习\包的本质分析.png)]

包的三大作用

1. 区分相同名字的类
2. 当类很多时，可以很好的管理类(参考Java API文档)
3. 控制访问范围

包基础语法

package com.xxxx;
说明

1. package关键字表示打包
2. com.xxxx表示包名

package com.use;

import com.xiaoqiang.Dog;

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog);//com.xiaoqiang.Dog@1b6d3586

        com.xiaoming.Dog dog1 = new com.xiaoming.Dog();
        System.out.println(dog1);//com.xiaoming.Dog@4554617c
    }
}

包的命名

**命名规则：**只能包含数字、字母、下划线、小圆点，但不能用数字开头，不能是关键字或者保留字

**命名规范：**一般是小写字母+小一点
一般是 com.公司名.项目名.业务模块名
例如：com.sina.crm.user

常用的包

一个包下，包含很多的类，java中常用的包由：
java.lang.* //lang包是基本包，默认引入，不需要再引入
java.util.* //util包，系统提供的工具包，工具类
java.net.* //网络包，网络开发
java.awt.* //是坐java的界面开发，GUI

如何引用包

语法：import 包;

我们引入一个包的主要目的是要使用该包下的类
比如：
import java.util.Scanner；就只是引入一个类Scanner
import java.util.*; 表示将java.util包所有类都引入

package com.xiaban;

import java.util.Arrays;

//注意：
//我们需要用到哪个类，就导入哪个类
//import java.util.Scanner;//表示只会引入一个类Scanner
//import java.util.*;//表示将java.util包所有类都引入
public class Import01 {
    public static void main(String[] args) {

        int[] arr = {-1,20,2,13,3};

        Arrays.sort(arr);

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");//-1 2 3 13 20
        }
    }
}

注意事项和使用细节

1. package的作用是声明当前类所在的包，需要放在class的最上面，一个类中最多只有一句package
2. import指令位置放在package的下面，再累定义的前面，可以由多句且没有顺序要求

访问修饰符

基本介绍(com.xiaban.modifier)

java提供四种访问修饰符号，用于控制方法和属性(成员变量)的访问权限(范围):

1. 公开级别：用public修饰，对外公开
2. 受保护级别：用protected修饰，对子类和同一个包中的类公开
3. 默认级别：没有修饰符号，向同一个包的类公开
4. 私有级别：用private修饰，只有类本身可以访问，不对外公开

使用的注意事项

1. 修饰符可以用来修饰类中的属性，成员方法以及类
2. 只有默认和public才能修饰类，并且遵循上述访问权限的特点
3. 成员方法的访问规则和属性完全一样

面向对象编程三大特征——封装、继承和多态

封装

基本介绍

封装(encapsulation)就是把抽象出的数据[属性]和对数据的操作[方法]封装在一起，数据被保护在内部，程序的其它部分只有通过被授权的操作[方法]，才能对数据进行操作——对电视机的操作就是典型封装

封装的理解和好处

1. 隐藏实现细节
2. 可以对数据进行验证，保证安全合理

封装的实现步骤(Encap01.java)

1. 将属性进行私有化private 【不能直接修改属性】
2. 提供一个公共的(public)set方法，用于对属性判断并赋值
   public void setXxx(类型 参数名){//Xxx表示某个属性
   ​ //加入数据验证的业务逻辑
   ​ 属性 = 参数名；
   }
3. 提供一个公共(public)的get方法，用于获取属性的值
   public XX getXxx(){//权限判断
   ​ return xx;
   }

package com.xiaban.encap;

public class Encapsulation01 {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("jack");
        person.setAge(30);
        person.setSalary(30000);
        System.out.println(person.info());

    }
}

class Person{
    public String name;//名字公开
    private int age;//age 私有化
    private double salary;//..

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age >= 1 && age <= 120){
            this.age = age;
        }else{
            System.out.println("年龄需要在1-120之间");
            this.age = 18;//给一个默认值
        }

    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String info() {
        return "消息为name = " + name + " age = " + age + " 薪水 = " + salary;
    }
}

将封装和构造器结合

package com.xiaban.encap;

public class Encapsulation01 {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("jack");
        person.setAge(30);
        person.setSalary(30000);
        System.out.println(person.info());

        Person smith = new Person("smith", 18, 50000);
        System.out.println(smith.info());
    }
}

class Person{
    public String name;//名字公开
    private int age;//age 私有化
    private double salary;//..

    public Person(){

    }
    public Person(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
        setName(name);
        setAge(age);
        setSalary(salary);
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age >= 1 && age <= 120){
            this.age = age;
        }else{
            System.out.println("年龄需要在1-120之间");
            this.age = 18;//给一个默认值
        }

    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String info() {
        return "消息为name = " + name + " age = " + age + " 薪水 = " + salary;
    }
}

继承

基本介绍

继承可以解决代码复用，让我们的编程更加靠近人类思维，当多个类存在相同的属性(变量)和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，值需要通过extends来声明继承父类即可

基础语法

class 子类 extends 父类{

}
注意

1. 子类就会自动拥有父类定义的属性和方法
2. 父类又叫超类，基类
3. 子类又叫派生类

父类

package com.xiaban.extend_.improve_;

public class Student {
    String name;
    int age;
    private double score;

    public void setScore(double score) {
        this.score = score;
    }

    public void showInfo(){
        System.out.println("学生名"+name+"年龄"+age+"得了"+score+"分");
    }
}

子类1

package com.xiaban.extend_.improve_;

public class Pupil extends Student{

    public void testing(){
        System.out.println("小学生"+name+"正在考式");
    }

}

子类2

package com.xiaban.extend_.improve_;

public class Graduate extends Student{

    public void testing(){
        System.out.println("大学生"+name+"正在考式");
    }
}

继承的深入讨论/细节问题

1. 子类继承了所有的属性和方法，但是私有属性不能再子类直接访问，要通过公共的方法访问
   (即父类的公共方法里返回一个属性，然后在子类调用父类的公共方法)

2. 子类必须调用父类的构造器,完成父类的初始化

3. 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作

4. 如果希望指定去调用父类的某个构造器，则显式的调用一下：super(参数列表)

   public Sub(String name){
           super("pick");
           System.out.println("Sub(String name)构造器被调用");
       }
   

5. super()和this()都只能放在构造器的第一行，因此俩个方法不能共存在一个构造器

6. java所有类都是Object类的子类
   

   IDEA ctrl+H查看继承关系

7. 父类构造器的调用不限于直接父类，将一直往上追溯直到Object类(顶级父类)

8. 子类最多只能继承一个父类(指直接继承)，即java中是单继承机制

9. 不能滥用继承，子类和父类之间必须满足is-a的逻辑关系(规范)

继承的本质分析

package com.xiaban.extend_;

public class ExtendsTheory {
    public static void main(String[] args) {
        Son son = new Son();
        System.out.println(son.name);//"大头蛾子"
    }
}

class GrandPa{
    String name = "大头爷爷";
    String hobby = "旅游";
}
class Father extends GrandPa{
    String name = "大头爸爸";
    int age = 39;
}
class Son extends Father {
    String name = "大头蛾子";
}

super关键字

基本介绍

super代表父类的引用，用于访问父类的属性、方法、构造器

基本语法

1. 访问父类的属性，但不能访问父类的private属性
   super.属性名
2. 访问父类的方法，不能访问父类的private方法
   super.方法名(参数列表)
3. 访问父类的构造器
   **super(参数列表);**只能放在构造器的第一句，只能出现一句

package com.xiaban.super_;

public class B extends A{
    public void hi(){
        System.out.println(super.n1 + " " + super.n2 + " " + super.n3);
    }

    public void ok(){
        super.test100();
        super.test200();
        super.test300();
    }

    public B() {
        //super();
        //super("smith");
        super("smith",6);
    }
}

super给编程带来的便利/细节

1. 调用父类的构造器的好处——分工明确，父类属性由父类初始化，子类属性由子类初始化
2. 当子类中有和父类中的成员(属性和方法)重名时，为了访问父类的成员，必须通过super。如果没有重名，使用super、this、直接访问是一样的效果
3. super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员；如果多个基类中都有同名的成员，使用super访问遵循就近原则

super和this的比较

方法重写/覆盖(override)

基本介绍

简单来说，方法重写(覆盖)就是子类的一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法重写/覆盖了父类的那个方法
父类

package com.xiaban.override_;

public class Animal {
    public void cry(){
        System.out.println("动物叫唤");
    }
}

子类

package com.xiaban.override_;

public class Dog extends Animal{
    public void cry(){
        System.out.println("旺旺旺");
    }
}

方法调用

package com.xiaban.override_;

public class Override01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.cry();//ctrl+b查找cry
        //输出  旺旺旺
    }
}

注意事项和使用细节

方法重写也叫方法覆盖，需要满足下面的条件

1. 子类的方法的形参列表、方法名称要和父类方法的形参列表名称完全一样

2. 子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类

   public Object m1(){}
   public String m1(){}
   //上面这样也能构成方法重写
   

   但是返回类型为Object的必须为父类

3. 子类方法不能缩小父类方法的访问权限

重写和重载

多态

多[多种]态[状态]基本介绍

方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的

多态的具体表现

package com.xiaban.poly_;

public class PloyMethod {
    public static void main(String[] args) {
        A a = new A();
        //方法重载
        System.out.println(a.sum(10,20));//30
        System.out.println(a.sum(10,20,30));//60
        //多态
        B b = new B();
        a.say();//A say()方法被调用
        b.say();//B say()方法被调用

    }
}

class B{
    public void say(){
        System.out.println("B say()方法被调用");
    }
}

class A extends B {
    public int sum(int n1, int n2){
        return n1 + n2;
    }
    public int sum(int n1,int n2, int n3){
        return n1 + n2 + n3;
    }
    public void say(){
        System.out.println("A say()方法被调用");
    }
}

对象的多态

1. 一个对象的编译类型和运行类型可以不一致

   Animal animal = new Dog();//animal编译类型是Animal,运行类型是Dog
   

2. 编译类型在定义对象时，就确定了，不能改变

3. 运行类型是可以变化的

package com.xiaban.poly_.PolyObject_;

public class PolyObject {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.cry();//运行类型是Dog 所以调用的是Dog 的cry()

        animal = new Cat();
        animal.cry();//运行类型是Cat 所以调用的是Cat 的cry()
    }
}

注意事项和细节讨论

​ 多态的前提是：两个对象(类)存在继承关系

​ 多态的向上转型

1. 父类的引用指向了子类的对象
2. 多态可以调用父类中的所有成员但需要遵循访问权限
3. 不能调用子类中特有成员
4. 最终运行效果看子类的具体实现

package com.xiaban.poly_.detail;

public class PolyDetail {
    public static void main(String[] args) {
        Animal animal = new Cat();
        Object object = new Cat();

        //animal.catchMouse();//catchMouse是Animal的子类Cat的方法，所以不能用

        animal.eat();//猫吃鱼
        animal.run();//跑
        animal.show();//hello
        animal.sleep();//睡
    }
}

public class Animal {
    String name = "动物";
    int age = 10;
    public void sleep(){
        System.out.println("睡");
    }
    public void run(){
        System.out.println("跑");
    }
    public void eat(){
        System.out.println("吃");
    }
    public void show(){
        System.out.println("hello");
    }
}

public class Cat extends Animal{
    public void eat(){//方法重写
        System.out.println("猫吃鱼");
    }
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

​ 多态的向下转型

1. 语法：子类类型 引用名 = (子类类型) 父类引用
2. 只能强转父类的引用，不能强转父类的对象
3. 要求父类的引用必须指向的是当前目标类型的对象
4. 向下转型后，可以调用子类类型中所有的成员

Cat cat = (Cat) animal;
cat.catchMouse();//猫抓老鼠

注意

1. 属性没有重写之说，属性的值是看编译类型
2. instanceOf比较操作符，用于判断对象的运行类型是否为XX类型或者XX类型的子类型

java的动态绑定机制

1. 当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定
2. 当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用

package com.xiaban.poly_.dynamic_;

public class Dynamic {
    public static void main(String[] args) {
        A a = new B();
        System.out.println(a.sum());//30
        System.out.println(a.sum1());//110
        System.out.println(a.getI());//10
    }
}

class A {
    public int i = 10;
    public int sum(){
        return getI() + 10;
    }
    public int sum1(){
        return i + 100;
    }
    public int getI(){
        return i;
    }
}

class B extends A{
    public int i = 20;
//    public int sum(){
//        return i + 20;
//    }
    public int getI(){
        return i;
    }
 //   public int sum1(){
 //       return i + 10;
 //   }
}

多态的应用1——多态数组

数组的定义类型为父类类型，里面保存的实际元素类型为子类类型

public class PloyArr {
    public static void main(String[] args) {

        Person[] persons = new Person[5];
        persons[0] = new Person("jack",20);
        persons[1] = new Student("caoc",20,80);
        persons[2] = new Student("smith",19,50);
        persons[3] = new Teacher("scott",30,200000);
        persons[4] = new Teacher("king",29,100000);

        for (int i = 0; i < persons.length; i++){
            System.out.println(persons[i].say());
        }
    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

    public String say(){
        return name + "\t" + age;
    }
}

class Student extends Person{
    private double score;

    public Student(String name, int age, double score) {
        super(name, age);
        this.score = score;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public String say(){
        return super.say() + "score = " + score;
    }
}

class Teacher extends Person{
    private double salary;

    public Teacher(String name, int age, double salary) {
        super(name, age);
        this.salary = salary;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String say(){
        return super.say() + "salary = " + salary;
    }
}

上面输出的结果为
jack 20
caoc 20 score = 80.0
smith 19 score = 50.0
scott 30 salary = 200000.0
king 29 salary = 100000.0

多态的应用2——多态参数

方法定义的形参类型为父类类型，实参类型允许为子类类型