编程语言
首页 > 编程语言> > Java第七天

Java第七天

作者：互联网

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的比较

No.区别点thissuper
1访问属性访问本类中的属性，如果本类没有此属性，则从父类中继续查找从父类开始查找属性
2调用方法访问本类中的方法，如果本类没有此方法则从父类继续查找从父类开始查找方法
3调用构造器调用本类构造器调用父类构造器
4特殊表示当前对象子类中访问父类对象

方法重写/覆盖(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. 子类方法不能缩小父类方法的访问权限

重写和重载

名称发生范围方法名形参列表返回类型修饰符
重载(overload)本类必须一样类型，个数或者顺序至少有一个不同无要求无要求
重写(override)父子类必须一样相同子类重写的方法的返回类型和父类方法的返回类型一致或者是其子类子类方法不能缩小父类方法的访问范围

多态

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

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

多态的具体表现

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——多态参数

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

标签：Java,name,子类,age,void,父类,public,第七天
来源： https://blog.csdn.net/xiaban_/article/details/123141436