java学习笔记---3

32.继承中构造方法的访问

1.背景: 创建子类和父类的构造方法时,在测试类中运行

2.特点:
子类中的所有的构造方法都会默认访问父类中的无参构造方法；
why？
1.因为子类会继承父类中的数据，可能还会使用父类中的数据，所以，子类初始化之前，一定要先完成父类数据的初始化；
2.每个子类的构造方法第一条默认语句都是：super（）；

//通过子类访问父类中的带参构造方法：super（参数）；

2022/1/11
“我想回家555555555”

33.继承中成员方法的访问

1.例子



运行结果：

可知：子类继承父类，同时也继承父类中的成员方法，可以直接使用；

例子2：
若子类总有和父类相同的方法

运行结果：

可知：如果子类中有和父类相同的成员方法，这测试类中会优先调用子类的；

例子3：
若子类和父类中有相同的方法，若想同时也调用父类中的方法，则可采用super.方法（）；

运行结果：

34.方法重写

1.是什么？ 子类中出现和父类一模一样的方法声明；
2.应用场景？ 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类的方法，这样既延继了父类的功能，又定义了子类特有的内容；
3.练习：
//比如有一个手机类，它可以实现打电话功能；
//现在出了一款新式手机，它可以在打电话之前开启视频功能；
如下：


新老手机测试如下：

结果：

可知：新老手机又一个相同的方法，不同的是，新手机在这个方法里增加了功能，由于是新增的，我们可以采用重新功能省去新手机里和旧手机相同的代码编写，重新方法 ：super.方法名（参数）；

运行结果：

//一个注解：@Override
检查重写方法的方法声明的正确性；

4.方法重新的注意事项：


//Override报错说明：父类中的私有方法是不能被子类继承，所以子类根本不能重新；
//子类重新父类的时候：访问权限不能比父类低；
（public>默认>private）

35.继承的注意事项

1.java中不可多个继承，一个子类只能继承一个父类；
2.java可以多层继承（比如父亲类继承爷爷类，儿子继承父亲类，这时相当于儿子也继承了爷爷类）

36.继承中的案例

例子1.老师学生类：
//需求：定义老师类和学生类，然后写测试类；最后找到老师类和学生类当中的共性内容，抽取出一个父类，用继承的方式改写代码，进行测试；

1.老师类（姓名、年龄、教学）
2.学生类（姓名、年龄、学习）
3.测试类
4.共性抽取父类，定义人类（姓名，年龄）
5.定义老师类，继承人类，给出自己的特有方法：教学；
6.定义学生类，继承人类，给出自己的特有方法：学习；

具体代码和运行结果：用继承的方法定义老师学生类

2022/1/12 每日一问： 陕一刀能不能不画饼了？!

例子2：猫和狗

//需求：采用继承的思想实现猫和狗的案例

1.猫：
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：get/set方法，抓老鼠

2.狗：
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：get/set方法，看门

3.共性：
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：get/set方法

具体代码：猫鼠类（继承）

37.导包

使用不同包里的类的方法

1.假如要在family这个包的测试类中调用animal中的dog类
方法：在调用这个类的前边加上包

同理调用Scanner类也可以使用 直接在创建对象处加包名

38.修饰符

一.类： 权限修饰符；状态修饰符；

二.权限修饰符：

java中的四种权限修饰符：
private < 默认 < protected < public；

2.1.测试看在本类中哪些修饰符可以被访问到：
//ans:都可以访问到

package XiuShiFU;

public class Fu {  //四种权限修饰符的使用

    private void show1(){
        System.out.println("private");
    }

    void show2(){
        System.out.println("默认");
    }

    protected void show3(){
        System.out.println("protected");
    }

    public void show4(){
        System.out.println("public");
    }

    public static void main(String[] args) {  //测试看在本类中哪些方法能够使用

        Fu f = new Fu();
        f.show1();
        f.show2();
        f.show3();
        f.show4();

    }
}

测试结果：（都可以访问到）

3.在同一个包下的子类继承父类，看哪些修饰符可以被访问

ans：除private外都可以被访问到

子类：

3.在其他类中可以访问的修饰符

ans：除private外都可以被访问到

4. 不同包下可以访问的修饰符
ans:只能访问public类

小结：

修饰符	同一个类	同一个包子类无关类	同一个类非子类	不同包的子类	不同包的非子类
private	可
默认	可	可	可
protected	可	可	可	可
public	可	可	可	可	可

三.状态修饰符
1.类： final（最终态）； static（静态）；

2.final类： 可以修饰成员方法，成员变量，类；

2.1特点：

不修饰父类时：



测试结果：

可知：子类可以对父类中的方法进行重写，在测试类中优先访问子类的方法

1.若采用final修饰父类：

可知：
在子类中不能正常重新父类的方法；
这是因为被final修饰的方法是最终方法，最终方法是不可以被重新的；

2.采用final修饰成员变量：

这里可知：在子类中，成员方法对age赋值为20，但在show方法里对age进行了重新赋值结果输出为show方法里的值

3.若对成员变量的age采用final修饰：

可知：final修饰的成员变量不能再次赋值了

4.采用final修饰类：

可知：用final修饰的类是最终类，她不可以再被继承；

5.final修饰局部变量

//f是是引用类型的变量

引用类型的变量用final修饰之后：

why？
因为引用类型采用final后，是把他的地址值变成了最终太，地址不能变但是值可以变；


2022/1/13 距离我考研完已经过去了19天，我曾经无数次幻想过考研结束的美好生活，能够去见想见的人，去向往的城市体验一下不同的生活；结果现在这个疫情，把我又搞回那种三点一线的生活轨迹，我已经半年没出过学校了，我也不想出去玩了 我就想回家了。。

3.static静态修饰符

1.定义： static是静态的意思，可以修饰成员方法，成员变量；
2.应用背景：
现在有一个学生类，包括，姓名、年龄、学校，现在录入学生信息可知除了姓名和年龄，学校的信息都是一样的；

package StaticBianLiang;

public class Student { //学生类

    public String name;
    public int age;
    public String university;

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

package StaticBianLiang;

public class StaticDemo {  //测试类
    public static void main(String[] args) {

        Student s = new Student();
        s.name = "龙杰";
        s.age = 19;
        s.university = "山科大";  //院校信息一样
        s.show();

        Student ss = new Student();
        ss.name = "王名";
        ss.age = 22;
        ss.university = "山科大"; //院校信息一样
        ss.show();
    }
}

运行结果：

采用static给成员变量赋值，表示这个变量是共享变量，只需一次赋值

应用背景2（成员方法）

3.特点：

• 被类的所有对象共享；（判断是否使用静态关键字的条件）
• 可以通过类名调用（推荐），也可以通过对象名调用；
• 非静态的成员方法，可以访问：静态的成员变量、非静态成员变量、静态成员方法、非静态成员方法。
• 静态的成员方法，只能访问：静态的成员变量和方法。

39. 多态

1.多态的概述： 同一对象在不同时刻表现出的不同形态；

2.举例： 猫

• 猫可以是猫： 猫 cat = new 猫（）；
• 猫可以是动物： 动物 animal = new 猫（）；
• //也就是说猫在不同时刻表现出不同形态；

3.多态的前提和体现

• 有继承/实现关系；
• 有方法重写；
• 有父类引用指向子类对象；
  
  
  

4.多态中成员的访问特点

Animal a = new Cat();

成员变量：(a.age) 编译看左边，执行看左边；（animal）
成员方法（a.eat()） 编译看左边，执行看右边（cat）
why？ 因为成员方法有重写，成员变量没有；



结果：（父类中的）

5.多态的好处和弊端

• 好处：提高了程序的可扩展性

•  具体体现：定义方法的时候，使用父类作为参数，将来使用的时候，使用具体的子类参与操作
  

• 弊端：不能使用子类特有的功能

2022/1/15 今天有了新希望了 ，25号解封，其实我最近的状态已经调整好了，疫情当下，如果能回家过年真就挺幸福的了。与其整日骂骂咧咧抱怨还不如踏踏实实学一些东西，在初试成绩出来之前，做好充足准备，拿出准研究生的素养，学习！

6.多态的转型

• 向上转型：
  从子到父
  父类引用指向子类对象
  
  
  
  //把子类的对象赋值给父类的引用

• 向下转型：
  从父到子
  父类引用转向子类对象

//向下转型：通过向下转型解决了子类访问的弊端：不能访问子类特有功能；

7.案例： 用多态的方法实现猫狗类

2022/1/16

40.抽象类

1.概述： 在java中，一个没有方法体的方法定义为抽象方法，而类中如果有抽象方法，该类就是抽象类。
2.例子

创建一个动物类在动物类中给出吃东西方法

package ChouXiang;

public class Animal {

    public void eat(){
        System.out.println("动物吃东西！");
    }
}

package ChouXiang;

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

        Animal a = new Animal();
        a.eat();
    }
}

这样做的弊端：假如有个猫类或者狗类继承动物类，在调用eat方法后，并没有重写eat方法，导致不管什么动物都是吃一样的东西，这样做过于笼统，所以在动物的eat方法内不应该给出具体的实现。

3.抽象类的特点：

1. 抽象类里边可以有抽象方法也可以有非抽象方法；
2. 一个类里有抽象方法那么这个类必须是抽象类；
3. 抽象类里不能直接创建具体对象；
4. 抽象类可以参照多态的方法通过子类对象来创建对象；
5. 抽象类的子类要么重写父类中的所有抽象方法；
6. 抽象类的子类要么也是一个抽象类

package ChouXiang;

public abstract class Animal {  //抽象类

    public abstract void eat();  //抽象方法

    public void sleep(){     //非抽象方法
        System.out.println("睡觉");
    }
}

package ChouXiang;

public class Cat extends Animal{

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

package ChouXiang;

public abstract class Dog extends Animal{
}

package ChouXiang;

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

//        Animal a = new Animal();
//        a.eat();

        Animal a = new Cat();
        a.eat();
        a.sleep();
    }
}

4.抽象类的成员特点

1. 抽象类中可以有常量，也可以有变量；
2. 抽象类中可以有抽象方法也可以有非抽象方法；
3. 抽象类中可以有构造方法；

public abstract class ChouXiangl {
    
    private int age = 20;  //变量
    private final String city = "北京";  //常量
    
    public void show(){  //非抽象方法  （提高代码的复用性）
        age = 40;
        System.out.println(age);
        System.out.println(city);
    }
    
    public abstract void eat();  //抽象方法

    public ChouXiangl() {  //构造方法  （抽象类中的构造方法用于子类访问父类数据的初始化）
    }

    public ChouXiangl(int age) {  //带参构造方法
        this.age = age;
    }
}

案例：猫狗类抽象类版： 猫狗抽象类

2022/1/24
（回家了！！！！ 哈哈哈 我已经在家躺尸好几天了，真开心。）

41.接口

1.接口的概述： 接口是一种公共的规范，只要符号规格标准，大家都可以通用。Java中的接口更多体现在对行为的抽象。

2.接口的特点：

1. 接口用关键字interface修饰；
   public interface 接口名（）{}
2. 类实现接口用implements表示（相当于继承）；
   public class 类名 implements 接口名{}
3. 接口不能实例化；
   接口可以通过多态的方式，通过实现类对象的实例化，这叫接口的多态。
   多态的形式：具体类多态，抽象类多态，接口多态；
   多态的实现前提：有继承或者实现关系；有方法重写；有父（类/接口）引用指向(子/实现）类对象。
4. 接口的实现类： 要么重写接口的所有抽象方法；要么是抽象类；

接口的创建：

关于调高的一个接口类：

package JieKou;
/*
* 定义的一个接口
* */
public interface Jumpping {

    public abstract void jump(); //抽象类
}

猫类继承接口类并重写抽象方法：

package JieKou;

public class Cat implements Jumpping{

    @Override
    public void jump(){
        System.out.println("猫跳的老高了！");
    }
}

狗类直接定义为抽象类并继承接口：

package JieKou;

public abstract class Dog implements Jumpping{
}

测试类：

package JieKou;

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

        //Jumpping jj = new Jumpping();  说明接口类是抽象类，它不可以创建具体的对象！

        Jumpping j = new Cat();
        j.jump();
    }
}

3.多态的成员特点：

• 成员变量
  只能是常量
  默认修饰符是：public static final

• 构造方法
  接口没有构造方法，因为接口主要是对行为进行抽象，是没有具体的存在的；
  一个类没有父类，默认继承Object类；

• 成员方法：
  只能是抽象方法
  默认修饰符为：public abstract

接口：

package JieKou;

public interface Inter {  //一个接口

   //接口中的成员变量
    public int num = 20;   //变量
    public final int num2 = 30;  //常量
    public static final int num3 = 40;  //默认态

}

接口的实现类：

package JieKou;


//public class InterImpGouZao implements Inter{}
public class InterImpGouZao extends Object implements Inter{

    public InterImpGouZao(){
        super();
    }
}

测试类：

package JieKou;

public class InterImpl implements Inter {  //接口的实现类
    public static void main(String[] args) {

        Inter i = new InterImpl();

        System.out.println(i.num);
        System.out.println(i.num2);
        System.out.println(Inter.num3);
    }
}

4.案例：猫和狗
//需求：对猫和狗进行训练，他们就可以调高了，在这里加入跳高功能。
采用抽象类和接口实现猫狗案例；
具体代码： 猫狗类（接口）

5.类和接口的关系：

• 类和类的关系：
  继承关系：但只能单继承，可以多层继承；
• 类和接口关系：
  实现关系：可以单实现，也可以多实现，还可以继承一个类的同时实现多个接口；
• 接口和接口关系:
  继承关系：可以继承，也可以多继承；

6.抽象类和接口的区别：

区别	抽象类	接口类
成员区别	变量，常量，构造方法，抽象方法，非抽象方法	常量，抽象方法
关系区别	对类抽象，包括属性、行为	对行为抽象，主要是行为

案例：门和警报案例

//我们知道门可以关和开，实现这个，我们既可以用抽象类也可以用接口

//随着时代的发展，优秀的门还会具有报警功能

//但是：有报警的门又不是人人家里都有，有的人觉得没必要就不买警报门，所以上述的定义方案都是不完美的；
最好的解决方案：将门的开关作为抽象类，报警的作为一个接口，如果有需要报警门就可以让这个类继承抽象类实现接口：

//再次强调：抽象类是对事物的抽象，接口是对行为的抽象；

7.案例（运动员教练）

//需求:我们现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练。为了出国交流,跟乒乓球相关的人员都需要学习英语。请用所学知识分析，这个案例中有哪些具体类,哪些抽象类,哪些接口，并用代码实现

具体实现及代码：运动员教练（接口）

2022/1/26

42.形参和返回值问题

1.类名作为形参和返回值；

• 方法的形参是类名，其实需要的是该类的对象
• 方法的返回值是类名，其实返回的是该类的对象

package XingCanFanHuiZhi;

public class Cat {

    public void eat(){
        System.out.println("猫吃鱼");
    }
}

package XingCanFanHuiZhi;

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

        CatOperator co = new CatOperator();
        Cat c  = new Cat();
        co.useCat(c);
    }
}

package XingCanFanHuiZhi;

public class CatOperator {

    public void useCat(Cat c){ //Cat类作为形参
        c.eat();
    }

}

测试结果：

注意：

2.抽象类名作为形参和返回值

• 方法的形参是抽象类名，其实需要的是该抽象类的子类对象；
• 方法的返回值是抽象类名，其实返回的是该抽象类的子类对象；

3.接口名作为形参和返回值

• 方法的形参是接口名，其实需要的是该接口的实现类对象；
• 方法的返回值是接口名，其实返回的是该接口的实现类对象；

43.内部类

1.概念： 内部类就是在一个类中定义一个类。
eg：在一个类A的内部定义一个B类，B类就成为内部类；

2.格式与范例：

3.内部类的访问特点：

• 内部类可以直接访问外部类的成员，包括私有；
• 外部类要访问内部类的成员，必须创建对象；

package NeiBuiLei;

public class Outer {
    
    private int num = 20;
    
    public class Inter{ //内部类可以直接访问外部类成员包括私有
        public void show(){
            System.out.println(num);
        }
    }
    
    public void method(){ //外部类不可以直接访问内部类，必须创建对象
        Inter i = new Inter();
        i.show();
    }
}

4.成员内部类：
1.分类: 按照内部类在类中定义的位置不同，可以分为如下两种形式：

• 在类的成员位置：成员内部类
• 在类的局部位置：局部内部类
• 匿名内部类

2.成员内部类的格式：

格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象；
eg: Outer.Inter oi = new Outer().new Inter();

package NeiBuiLei;

public class Outer {

    private int num = 10;

    public class Inter{   //成员内部类
        public void show(){
            System.out.println(num);
        }
    }

}

package NeiBuiLei;

public class InnerDemo {
    public static void main(String[] args) {
        //创建内部类对象，调用方法

        Outer.Inter oi = new Outer().new Inter();
        oi.show();
    }
}

//但是我们一般不是这么调用内部类的，我们创建内部类的目的是为了隐藏这个类，并不对外界直接开放；所以一般对于内部类的修饰是private；

package NeiBuiLei;

public class Outer {

    private int num = 10;

    private class Inter{   //成员内部类
        public void show(){
            System.out.println(num);
        }
    }

    public void method(){
        Inter i = new Inter();
        i.show();
    }

}

package NeiBuiLei;

public class InnerDemo {
    public static void main(String[] args) {
        //创建内部类对象，调用方法
        Outer o = new Outer();
        o.method();
    }
}

5.局部内部类

• 局部内部类是在方法中定义的类，所以外界无法直接使用，需要在方法内部创建对象并使用
• 该类可以直接访问外部类成员，也可以访问方法内部的局部变量；

package NeiBuiLei;

import JieKou.Inter;

public class Outer {

    private int num = 10;

    public void method(){
        final int num2 = 20;
        class Inner{    //局部内部类
            public void show(){
                System.out.println(num);
                System.out.println(num2);
            }
        }

        Inner i = new Inner();
        i.show();
    }
}

package NeiBuiLei;

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

        Outer o = new Outer();
        o.method();

    }
}

6.匿名内部类
1.前提： 存在一个类或者接口，这里的类可以是具体类也可以是抽象类；
2.格式与范例：

3.本质： 匿名内部类的本质实际是一个对象，它继承了该类或者实现了该接口的子类匿名对象

package NiMing;

public interface Inter {  //匿名内部类的前提（必须有个接口或者类）

    void show();  //默认抽象方法
}

package NiMing;

public class Outer {
    public void method(){
        new Inter(){  //匿名内部类
            @Override
            public void show(){
                System.out.println("匿名内部类");
            }
        }.show();
    }
}

package NiMing;

public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

多次调用， 可以直接对匿名内部类创建对象

4.匿名内部类在开发中的使用

背景 ：我们知道对于一个接口，它不能有具体的方法，一般都是抽象方法，然后在具体的类中实现接口，但是这样的弊端就是，我们需要对每一个具体的对象创建一个类并且去重写接口中的方法，过于繁琐。

匿名内部类 ：因为它的本质就是一个对象，而且是匿名的

package NiMing;

public interface Jumpping {  //接口
    void jump();
}

package NiMing;

public class JumppingOperator {

    public void method(Jumpping j){
        j.jump();
    }
}

package NiMing;

import java.sql.SQLOutput;

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

        JumppingOperator jo = new JumppingOperator();
        jo.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("猫会调高");
            }
        });

        jo.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("狗会调高");
            }
        });
    }
}

运算结果：

2022/1/27

44.常用ApI

学过的：String , StringBuilder;

1.Math :包含执行基本数字运算的方法；

特点：

• 在java.lang包内，使用时不用导包；
• 是最终类被final修饰： public final class Math;
• 继承Object类（所以的类都直接或者间接继承Object类）；
• 没有构造方法，但是可以直接通过类名直接调用；
• 成员方法和成员变量被static关键字修饰；

成员方法

• public static int abs(变量类型 变量): 返回参数的绝对值；
• public static double ceil(double a) : 返回大于等于a的最小double值，相当于一个整数；
• public static double floor(double a): 返回小于等于a的最大double值，相当于一个整数；
• public static int round(float a) : 四舍五入返回最接近参数a的int值；
• public static int max(int a , int b) : 返回两个int值中的较大值；
• public static int min(int a , int b) : 返回两个int值中的较小值；
• public static double pow(double a, double b) :返回a的b次幂；
• public static double random() : 返回值为double的正值，[0.0 ,1.0)

public class MathDemo { //Math常用方法
    public static void main(String[] args) {

        //绝对值
        System.out.println(Math.abs(88));  //88
        System.out.println(Math.abs(-88));  //88
        System.out.println(Math.abs(-12.36));  //12.36

        System.out.println("-------------------------");

        //最小/大double
        System.out.println(Math.ceil(3.14)); //4.0
        System.out.println(Math.floor(3.14));  //3.0

        System.out.println("-------------------------");

        //四舍五入
        System.out.println(Math.round(3.14));  //3
        System.out.println(Math.round(3.64));  //4

        System.out.println("-------------------------");

        //比较大小
        System.out.println(Math.max(12,15));  //15
        System.out.println(Math.min(12,15));   //12

        System.out.println("-------------------------");

        //返回幂次方
        System.out.println(Math.pow(2.0,3.0));   //8.0

        System.out.println("-------------------------");

        //返回double正值
        System.out.println(Math.random()); //随机一个0.几的小数
        System.out.println(Math.random()*100); 


    }
}

2.System： 终止虚拟机或者返回时间；

特点：

• 在java.lang包内，使用时不用导包；
• 是最终类被final修饰： public final class System;
• 继承Object类;
• 不能被实例化（即：不能创建对象）；
• 成员方法被静态修饰（所以不需要创建对象直接通过类名就可以访问）；

成员方法：

1. exit (int static) : 终止当前运行的虚拟机。（参数作为状态代码，非零状态下表示异常终止）；
2. currentTimeMillis( ) :返回当前时间距离1970的时间，单位为毫秒；

currentTimeMillis( )的另一个作用：记录程序所运行的时间：

3.Object： 类层次结构的根，没个类都有Object作为超类。所有对象包括数组都实现了这个类的方法；

特点:

• 含有一个无参构造方法：public Object()（构造一个新对象）；
  //子类的构造方法默认访问的是父类的无参构造方法，因为他们的顶级父类只有无参构造方法；
• 在java.lang包内，使用时不用导包；
• 定义格式：public class Object;

成员方法：

1. toString( ): 返回对象的字符串表示；
2. equal():

2.示例：

学生类：

package Obj;

public class Student {

    private int age;
    private String name;

    public Student() {
    }

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

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

测试类：

//看方法源码，选择方法按Ctrl+B
然后无限套娃直到找到

说明：

重写：在Student类里边对toString进行重写

测试结果：