Java两周半速成之路（第六天）

最新推荐文章于 2024-09-08 11:09:43 发布

灰太狼！！

最新推荐文章于 2024-09-08 11:09:43 发布

阅读量1.2k

点赞数 34

分类专栏： Java 文章标签： java 算法数据结构

本文链接：https://blog.csdn.net/weixin_52134189/article/details/136326513

版权

Java 专栏收录该内容

17 篇文章 2 订阅

订阅专栏

一、制作帮助文档

1.制作工具类：ArrayTools

文档注释：别的用途（生成帮助文档）

工具类： 1、构造方法私有化

2、方法必须是静态

演示：

/**
 * @author 小明
 * @version v1.0.0
 * 该类是数加小名写的专门针对数组做操作的工具类，可以对数组进行逆序，排序，打印数据，获取数组最大值，最小值等等
 */
public class ArrayTool {
    private ArrayTool(){}

    /**
     * 可以对一个元素类型为int类型的一维数组进行打印
     * 以指定的格式输出
     * 举例：
     *  输出：[2,3,1,5,6]
     * @param arr 传入一个元素类型为int类型的一维数组
     */
    public static void printArray(int[] arr) {
        for (int index = 0; index < arr.length; index++) {
            if (index == 0) {
                System.out.print("[" + arr[index] + ",");
            } else if (index == arr.length - 1) {
                System.out.println(arr[index] + "]");
            } else {
                System.out.print(arr[index] + ",");
            }
        }
    }

    /**
     * 对一个元素类型为int类型的一维数组进行冒泡排序
     * @param arr 传入一个元素类型为int类型的一维数组
     * @return 返回一个排序后的数组，元素从小到大排序
     */
    public static int[] BubbleSort(int[] arr){
        for(int i=0;i<arr.length-1;i++){  // 控制轮次
            for(int j=0;j<arr.length-i-1;j++){  // 控制每一轮的比较次数
                if(arr[j]>arr[j+1]){
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }

        return arr;
    }

    /**
     * 对一个元素类型为int类型的一维数组进行逆序
     * @param arr 传入一个元素类型为int类型的一维数组
     * @return 返回逆序后的数组
     */
    public static int[] niXu(int[] arr){
        for (int start = 0, end = arr.length - 1; start < end; start++, end--) {
            int tmp = arr[start];
            arr[start] = arr[end];
            arr[end] = tmp;
        }
        return arr;
    }

    /**
     * 从一个元素类型为int类型的一维数组获取最大值
     * @param arr 传入一个元素类型为int类型的一维数组
     * @return 返回一个最大值
     */
    public static int getMaxNumber(int[] arr){
        //1、默认第一个元素为最大值和最小值
        int maxNumber = arr[0];

        //2、从第二个元素开始依次遍历，与最大值和最小值进行比较
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > maxNumber) {
                maxNumber = arr[i];
            }
        }
        return maxNumber;
    }


    /**
     * 从一个元素类型为int类型的一维数组获取最小值
     * @param arr 传入一个元素类型为int类型的一维数组
     * @return 返回一个最大值
     */
    public static int getMinNumber(int[] arr){
        //1、默认第一个元素为最大值和最小值
        int minNumber = arr[0];

        //2、从第二个元素开始依次遍历，与最大值和最小值进行比较
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < minNumber) {
                minNumber = arr[i];
            }
        }
        return minNumber;

    }

}

2.制作帮助文档(API)

java可以根据文档注释生成一个文档说明书:

javadoc -d 目录 -author -version ArrayTool.java

1.如何使用Java官方给的帮助文档：

1）打开帮助文档

2）点击索引，输入要查询的类双击或者回车

3）看属于哪一个包下

<1>如果在java.lang包下，那么将来使用的时候，不需要导包，直接使用

<2>除了java.lang包下其他类，将来使用的时候都需要导包

4）看继承实现关系

5）看类的描述

6）看构造方法

<1>如果没有构造方法，意味着这个类中的方法是静态的，将来可以直接通过类名的方式调用，这个类属于工具类

<2>如果有构造方法，将来可以通过构造方法创建对象，通过对象调用非静态的方法

7、找对应的功能方法

举例：

根据上面的7步骤，学习新的类Math:

1、是属于java.lang，意味着将来使用的时候不需要导包

2、根据类的描述发现该类和数学操作相关

3、发现该类是没有构造方法，将来是通过类名的方式调用静态方法

4.举例：

public static double random(）

产生一个随机数返回一个double值大于等于0.0 ，小于1.0的数

5.练习：利用math.random方法完成一个猜数字小游戏

import java.util.Scanner;
/*
 * 猜数字小游戏
 */
public class NumberGame {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int randomNumber=(int)(Math.random()*100+1);  //生成1—100之间的任意整数

        while (true){
            System.out.print("请输入一个数字：");
            int number = sc.nextInt();
            if (number>randomNumber){
                System.out.println("该数大了，请往小了猜");
            } else if (number < randomNumber) {
                System.out.println("该数小了，请往大了猜");
            }else {
                System.out.println("恭喜你猜对了!!");
                break;
            }
        }

    }
}

结果：

二、代码块

1.代码块的概念：

代码块：使用大括号将代码括起来的整体，叫做代码块

2.分类：

局部代码块：将{}括起来的整体，在方法的内部定义，叫做局部代码块,在同一个方法中多个局部代码块的执行顺序是自上而下执行

构造代码块：将{}括起来的整体，在类中方法外定义，叫做构造代码块

静态代码块：将{}括起来的整体，在大括号前面加上static关键字，在类中方法外定义，叫做静态代码块

同步代码块：（放到多线程的时候讲解）

代码块的作用： 1、主要是限定变量的作用域

2、初始化值（放到下节课讲解）

3.优先级：（从高到低）

静态代码块 --> 构造代码块 --> 构造方法

演示:

class A {
    A() {
        System.out.println("这是A中的无参构造方法");         //第三个执行
    }

    {
        System.out.println("构造代码块");         //第二个执行
    }

    static {
        System.out.println("静态代码块");           //第一个执行
    }

    public void Print1() {
        System.out.println("2");
        {
            System.out.println("局部代码块2");
        }
    }

}

public class CodeKuai {
    public static void main(String[] args) {
        A a = new A();
//        a.Print1();
//        Print();

    }

    public static void Print() {
        System.out.println("1");
    }

    {
        System.out.println("局部代码块1");
    }
}

三、继承

1.概述：

继承：java针对多个类中有相同的部分的话，可以将相同的部分提取出来，单独放到一个类中A, 然后其他类与这个A类产生一个关系，这样的话其他类中就拥有了A类中的属性或者行为。这个关系叫做继承, java提供了一个关键字extends来表示继承关系。

单独的这个类称为父类，基类或者超类；

这多个类可以称为子类或者派生类

用法：class 子类名 extends 父类名 {}

继承的好处：

（1）提高了代码的复用性：多个类相同的成员可以放到同一个类中

（2）提高了代码的维护性：如果功能的代码需要修改，修改一处即可

（3）让类与类之间产生了关系，是多态的前提（其实这也是继承的一个弊端：类的耦合性很强）

2.继承使用原则：

1、子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。

2、java中的类与类之间的继承，不允许出现子类同时继承多个父类的情况，只允许单继承

3、java中的类与类之间的继承，允许多重继承，形成继承体系

4、java中子类无法继承父类中的私有成员

5、不要为了小部分功能而刻意去继承

演示：

package com.shujia.day07;
/*
 继承使用注意事项：
        1、子类无法继承父类中的构造方法
        2、java中的类与类之间的继承，不允许出现子类同时继承多个父类的情况，只允许单继承
        3、java中的类与类之间的继承，允许多重继承，形成继承体系。
        4、java中子类无法继承父类中的私有成员
        5、不要为了部分功能而去继承
 */

import java.util.NoSuchElementException;

class Animal {
    String name;
    private int age;

    public Animal() {

    }

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

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

    public void sleep() {
        System.out.println("睡觉");
    }
}


class Tiger extends Animal {
    public Tiger() {
    }

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

    public void fight(){
        System.out.println("打架");
    }
}

class DongBeiTiger extends Tiger{
    public DongBeiTiger() {
    }

    public DongBeiTiger(String name, int age) {
        super(name, age);
    }
}



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

//        Tiger tiger = new Tiger("xiaohua",19);
//        System.out.println(tiger.name+","+tiger.age);
//        tiger.eat();
//        tiger.sleep();

        DongBeiTiger dongBeiTiger = new DongBeiTiger();
        System.out.println(dongBeiTiger.name);             
//        Tiger tiger = new Tiger("老虎",10);
//        System.out.println(tiger.age);      // java中子类无法继承父类中的私有成员


    }
}

3继承与成员变量的关系: （就近原则）

总结：就近原则

4.super关键字

注意：

1、要想初始化子类，必须先初始化其直接父类(执行一遍父类的构造方法)

2、子类的构造方法第一句话默认是super()

3、java中的类只能进行一次初始化(super)，不允许重复初始化

演示：

/*
    1、要想初始化子类，必须先初始化其直接父类(执行一遍父类的构造方法)
    2、子类的构造方法第一句话默认是super()
    3、java中的类只能进行一次初始化(super)，不允许重复初始化
 */
class Fu3 {
//    Fu3(){
//        System.out.println("这是父类中的无参构造方法。。。");
//    }

    Fu3(String s) {
        System.out.println("你好 " + s);
    }
}

class Zi3 extends Fu3 {
    Zi3() {

        //方案1：当父类中没有无参构造方法的时候，使用super关键字调用其直接父类中的其他构造方法，完成父类初始化
//        super("java");
//        super();  // Fu3();

        //方案2：间接地调用父类的有参构造方法，完成父类的初始化
        this("java");

        System.out.println("这是子类中的无参构造方法。。。");
//        super();  // 不允许重复初始化
    }

    Zi3(String s){
        super(s);
        System.out.println("这是子类中的有参构造方法。。。");
    }
}

public class ExtendsDemo4 {
    public static void main(String[] args) {
        Zi3 zi3 = new Zi3();
    }
}

5. 继承中成员方法的关系：（就近原则）

总结：就近原则

6.方法的重写

方法的重写：子类中出现了和父类中一模一样的方法声明

【返回值类型，方法名，参数列表都和父类一模一样】

面试题：重载和重写的区别？ （Override和Overload的区别？）

1、重载是发生在同一个类中的，方法名相同，参数列表不同，与返回值无关的现象

2、重写是发生在继承关系中的，返回值类型，方法名，参数列表都和父类一模一样，只是实现不一样,使用 @Override检测方法能否重写

演示：

package com.shujia.day07;


class Father1{
    public void play(){
        System.out.println("会玩游戏");
    }
}
class Son1 extends Father1{

    @Override
    public void play(){
        System.out.println("会玩游戏");
        System.out.println("玩的好");
    }
}


public class ExtendsDemo5 {
    public static void main(String[] args) {
        Son1 son1 = new Son1();
        son1.play();

    }
}

权限修饰符的优先级：

java中有4个权限修饰符，权限从大到小依次为：

public---->protected---->默认(不写修饰符) ---->private

方法重写的注意事项：

1、子类无法重写父类中的私有成员方法

2、子类重写父类方法的时候，权限修饰符不能比父类中的权限还要小，只能大于等于父类方法的权限，推荐父类用什么修饰符，子类就用什么修饰符

3、子类无法重写父类中的静态方法，只能使用

总结：子类可以重写父类中的非私有，非静态的成员方法。

演示:

/*
java中有4个权限修饰符，权限从大到小依次为：public	protected  默认	private

    方法重写的注意事项：
        1、子类无法重写父类中的私有成员方法
        2、子类重写父类方法的时候，权限修饰符不能比父类中的权限还要小，只能大于等于父类方法的权限
            推荐父类用什么修饰符，子类就用什么修饰符
        3、子类无法重写父类中的静态方法，只能使用。
        4、总的来说，子类可以重写父类中的非私有，非静态的成员方法。
 */


class Father2 {

    private String fun2(String a) {
        System.out.println("方法2");
        return a;
    }


    protected void fun3() {
        System.out.println("方法3");
    }


    public static void fun4(){
        System.out.println("静态方法4");
    }
}


class Son2 extends Father2 {

//    @Override     // 子类无法重写父类中的私有成员方法
    public String fun2(String a) {
        System.out.println("重写后的方法2");
        return a;
    }

    @Override
    public void fun3() {                       //子类重写父类方法的时候，权限修饰符不能比父类中的权限还要小，只能大于等于父类方法的权限
        System.out.println("重写的方法3");
    }

//    @Override         //子类无法重写父类中的静态方法，只能使用。
//    public static void fun4(){
//        System.out.println("不是重写的静态方法4");
//    }

}


public class ExtendsDemo6 {
    public static void main(String[] args) {
        Son2 son2 = new Son2();
        son2.fun3();
        son2.fun4();
    }
}

7.final关键字

1.概述：

如果父类中的方法只想让子类继承使用，并不想让子类重写，java提供了一个关键字给我们使用做限制：final

final: 最终的，最后的，它可以修饰类，变量，成员方法

2.final关键字的使用特点：

类：被final修饰的类，类不能被继承

变量：被final修饰的变量，变量变常量（自定义常量）

方法：被final所修饰的方法，子类只能继承使用，不能进行重写

演示:

/*
    final关键字的使用特点：
        类：被final修饰的类，类不能被继承
        变量：被final修饰的变量，变量变常量（自定义常量）
        方法：被final所修饰的方法，子类只能继承使用，不能进行重写
 */


class Father3 {
    int a = 50;
    final int c = 100;      
    public final void fun5() {
        System.out.println("方法五");
    }
}

class Son3 extends Father3 {

    //    public void fun5() {                        //无法重写被final修饰的成员方法fun5
//        System.out.println("想要重写父类的方法5");
//    }
    public void fun6() {
        a = 30;
//        c = 2000;              //被final修饰的变量，变量变常量（自定义常量）
        System.out.println(a);
        System.out.println(c);
    }

}


public class ExtendsDemo7 {
    public static void main(String[] args) {
        Son3 son3 = new Son3();
//        son3.fun5();
        son3.fun6();
//        son3.c = 100;           //被final修饰的变量，变量变常量（自定义常量）
        System.out.println(son3.c);


    }
}

四、多态

1.多态概述：

1.多态：某一个事物，在不同时刻表现出来的不同状态

2.举例：

水：固态，气态，液态

3.实现多态的三大前提：（同时满足，缺一不可）

（1）要有继承关系

（2）要有方法的重写

（3）要有父类的引用指向子类对象（只有继承关系/实现关系才可以这么写）

2.成员访问特点：

（1）成员变量: 编译看左，运行看左

（2）成员方法: 编译看左，运行看右

（3）静态的成员方法: 编译看左，运行看左

成员访问练习：

看代码写结果:

package com.shujia.day07;

class A {
    public void show() {
        show2();
    }

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

class B extends A {
    public void show2() {
        System.out.println("爱");
    }
}

class C extends B {
    public void show() {
        super.show();
    }

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

public class Test {
    public static void main(String[] args) {
        A a = new B();
        a.show();

        B b = new C();
        b.show();
    }
}

结果：爱
你