开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> java学习笔记16（封装、访问权限修饰符、Arrlist 类、接口练习、数组练习、 ArrayList 练习） -> 正文阅读

[Java知识库]java学习笔记16（封装、访问权限修饰符、Arrlist 类、接口练习、数组练习、 ArrayList 练习）

10.21 学习内容

小 tips 几则

Shift + Enter

天啊！宝藏！
在 IDEA 中， shift + enter 可以直接换行而不会把光标后面的内容移到下一行。
找了好久的快捷键！！今天因为机缘巧合按错键然后被我发现了。

markdown中的` + `

可以让文字有一个小小的背景，在文字中介绍重要的类名、关键字、方法名的时候可以使用，以突出他们。养成这个习惯也可以让文章变的易读。

英文数字间距

文字中，英语与汉字、数字与汉字直接最好有一个空格，这样比较美观。举例如下
我是 1 只学习 java 的 panda。
我是1只学习java的panda。
明显第一句看起来舒服的多！

封装

导入类

使用 import 关键字来声明。

冲突

当导入的两个有相同类名的类库，创建这个相同类时，就会产生冲突。

解决方法是在类名前面加入类库名，指明这个类的位置。

访问权限修饰符

public

public 关键字表示后面的成员对于每个人都是可用的。

private

private 关键字表示除了包含该成员的类，其它任何类都无法访问这个成员。

####protected

protected 关键字是指，该成员只能被包含该成员的类类及其子类访问。

有关代码风格

在创建一个类时，以 public → protected → private 为顺序编写哥成员。好处是，类的使用者可以从头读起，先看到权限最大的部分（public），然后权限递减。

`ArrayList` 类

ArrayList 类相当于数组的加强版。普通数组经常会因为其大小无法更改而出现各种各样的不方便， ArrayList 类的引入可以解决这个问题。

优势

可以支持一些附加操作，而普通数组做不到。

删除元素而不留下空位置。
在数组开头/中间/尾部增加元素。

可以更改数组的大小。

使用方法

创建容器

ArrayList<T> list = new ArrayList<T>();

获取元素的数量

int n = list.size();

获取指定元素

String s = list. get(3)

将元素写入数组的指定位置

list.set(3,s);

工作内容

任务1

依据下图的类层次结构的定义，创建相应的类和接口，并实现两种不同的多态：重载和重写。
创建五个接口、三个类和两个对象；
人类实现吃饭、喝水、睡觉三个接口；
男人实现刮胡子接口，女人实现生孩子接口，男人类和女人类同时也要实现吃饭、喝水、睡觉三个接口；、李雷重载刮胡子接口（如增加不同数量和类型的参数），韩梅梅重写生孩子接口（如剖腹产和顺产不同的行为）。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ou3A59om-1634828901564)(https://img-community.csdnimg.cn/images/758719819dc44ab2a91bf9911d2c766f.png “=600 #left”)]

任务2

模仿上一题的类层次结构的定义，创建另一组类和接口（例如宠物-猫狗、衣服-男装女装等），同样按照上一题的要求实现。

package com.xxm.Task4;

/*
依据下图的类层次结构的定义，创建相应的类和接口，并实现两种不同的多态：重载和重写。
创建五个接口、三个类和两个对象；
人类实现吃饭、喝水、睡觉三个接口；
男人实现刮胡子接口，女人实现生孩子接口，男人类和女人类同时也要实现吃饭、喝水、睡觉三个接口；
李雷 重载刮胡子接口（如增加不同数量和类型的参数），
韩梅梅 重写生孩子接口（如剖腹产和顺产不同的行为）。
 */

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

        class Human implements Eat, Drink, Sleep {
            public void eat() {
                System.out.println("吃饭");
            }

            public void drink() {
                System.out.println("喝水");
            }

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

        class Man extends Human implements Shave {
            public void shave() {
                System.out.println("刮胡子");
            }
        }

        class Woman extends Human implements GiveBirthToABaby {
            public void giveBirth() {
                System.out.println("生孩子");
            }
        }

        class Lilei extends Man{
            public void shave(int n) {
                System.out.println("每" + n + "天刮一次胡子");
            }

            public void shave(String brand, int n) {
                System.out.println("每" + n + "天用" + brand + "牌剃须刀刮一次胡子");
            }

            public void shave(String brand) {
                System.out.println("每天用" + brand + "刮胡子");
            }
        }

        class Hanmeimei extends Woman{
            @Override
            public void giveBirth(){
                System.out.println("剖腹产");
            }
        }

        Lilei lilei = new Lilei();

        Woman hanmeimei = new Hanmeimei();

      /*
         其实这段代码可以运行
        Woman hanmeimei = new Woman() {
            @Override
            public void giveBirth() {
                System.out.println("剖腹产");
            }
        };
        */

        lilei.eat();
        lilei.drink();
        lilei.sleep();
        lilei.shave(365);
        lilei.shave("吉列");
        lilei.shave("吉列",1);

        hanmeimei.eat();
        hanmeimei.drink();
        hanmeimei.sleep();
        hanmeimei.giveBirth();
    }

    //吃饭接口
    public interface Eat {
        void eat();
    }

    //喝水接口
    public interface Drink {
        void drink();
    }

    //睡觉接口
    public interface Sleep {
        void sleep();
    }

    //刮胡子接口
    public interface Shave {
        void shave();
    }

    //生孩子接口
    interface GiveBirthToABaby {
        void giveBirth();
    }
}

任务2

package com.xxm.Task4;

public class Task4_2 {
    public interface Eat {
        void eat();
    }

    public interface Sleep {
        void sleep();
    }

    public interface Run {
        void run();
    }

    public interface Play {
        void play();
    }

    public interface EatAllTheDay {
        void eatAllTheDay();
    }

    public interface SleepAllTheDay {
        void sleepAllTheDay();
    }

    public static void main(String[] args) {
        class Cat implements Eat, Sleep, Run, Play {
            @Override
            public void eat() {
                System.out.println("yumm");
            }

            @Override
            public void run() {
                System.out.println("run!!");
            }

            @Override
            public void sleep() {
                System.out.println("zzZ");
            }

            @Override
            public void play() {
                System.out.println("砰砰砰,轰隆隆");
            }
        }

        class LazyCat extends Cat implements SleepAllTheDay {
            @Override
            public void sleepAllTheDay() {
                System.out.println("zzzzzzzzzzZZZZZZZ(for the whole day)");
            }
        }

        class OrangeCat extends Cat implements EatAllTheDay {
            @Override
            public void eatAllTheDay() {
                System.out.println("yumyumyumyum");
            }
        }

        class Pig extends OrangeCat {
            @Override
            public void play() {
                System.out.println("yummyumm");
            }

            public void eat(int a) {
                System.out.println("我已经 " + a + " 秒没吃饭了");
            }
        }

        class LadyLazy extends LazyCat {
            @Override
            public void play() {
                System.out.println("zzzZZZ");
            }
        }

        Pig piggy = new Pig();
        LadyLazy ladyLazy = new LadyLazy();


        piggy.run();
        piggy.eat();
        piggy.eat(3);
        piggy.play();
        piggy.eatAllTheDay();
        piggy.sleep();

        ladyLazy.eat();
        ladyLazy.play();
        ladyLazy.run();
        ladyLazy.sleep();
        ladyLazy.sleepAllTheDay();
    }

}

任务3

在实际开发中，经常会遇到面向对象的一些问题，比如「多重继承」，还原案发线程，整个过程大概是这样：
接口 A 和接口 B 拥有相同的方法；
接口 B 继承接口 A，C 是独立接口；
类 D 有和 A、B 相同的方法。

第一种情况：类 E 同时实现接口 A 和接口 B 时，会调用哪个接口的方法？
答：根据就近原则，会调用接口 B 的方法。

package com.xxm.Task4;

/*
接口 A 和接口 B 拥有相同的方法；
接口 B 继承接口 A，C 是独立接口；
类 D 有和 A、B 相同的方法。
 */
public class Task4_3_1 {
    interface A {
        default void run() {
            System.out.println("hello from A");
        }
    }

    interface B extends A {
        default void run() {
            System.out.println("hello from B");
        };
    }

    interface C {
        void fly();
    }

    class D {
        void run() {
            System.out.println("D:run");
        }
    }

    static class E implements A, B {
    }

    public static void main(String[] args) {
        E e = new E();
        e.run();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BjF1N12H-1634828901571)(https://img-community.csdnimg.cn/images/3140fb06b5244950a90ca79ebb057b0c.png “=600 #left”)]

第二种情况：类 E 继承 D，同时实现接口 A 和接口 B 时，会调用哪个方法？
答：调用的是类 D 的方法。

package com.xxm.Task4;

/*
接口 A 和接口 B 拥有相同的方法；
接口 B 继承接口 A，C 是独立接口；
类 D 有和 A、B 相同的方法。
 */
public class Task4_3_1 {
    public interface A {
        default void run() {
            System.out.println("hello from A");
        }
    }

    public interface B extends A {
        default void run() {
            System.out.println("hello from B");
        };
    }

    interface C {
        void fly();
    }

    static class D {
        public void run() {
            System.out.println("D:run");
        }
    }

    static class E extends D implements A, B {
    }

    public static void main(String[] args) {
        E e = new E();
        e.run();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bSO1pxOr-1634828901574)(https://img-community.csdnimg.cn/images/19572227486a4d36a67ff1b01da57250.png “=600 #left”)]

第三种情况：类 E 同时实现接口 A、接口 B 和接口 C 时，会调用哪个方法？
答：这种情况需要手动指定继承哪一个类，代码指定的接口 C。

package com.xxm.Task4;

/*
接口 A 、接口 B 、接口 C 拥有相同的方法；
接口 B 继承接口 A，C 是独立接口；
类 D 有和 A、B 相同的方法。
 */
public class Task4_3_1 {
    interface A {
        default void run() {
            System.out.println("hello from A");
        }
    }

    interface B extends A {
        default void run() {
            System.out.println("hello from B");
        }

        ;
    }

    interface C {
        default void run() {
            System.out.println("Hello from C");
        }

        ;
    }

    class D {
        void run() {
            System.out.println("Hello from D");
        }
    }

    static class E implements A,B,C{
        @Override
        public void run() {
            C.super.run();
        }
    }

    public static void main(String[] args) {
        E e = new E();
        e.run();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xa1BRBb9-1634828901576)(https://img-community.csdnimg.cn/images/30eec6db10f445babd95ffd3c9ec31c7.png “=600 #left”)]

第四种情况：类 E 继承 D，且同时实现接口 A、接口 B 和接口 C 时，会调用哪个方法？
答：会调用类 D。

package com.xxm.Task4;

/*
接口 A 和接口 B 拥有相同的方法；
接口 B 继承接口 A，C 是独立接口；
类 D 有和 A、B 相同的方法。
 */
public class Task4_3_1 {
    interface A {
        default void run() {
            System.out.println("hello from A");
        }
    }

    interface B extends A {
        default void run() {
            System.out.println("hello from B");
        }

        ;
    }

    interface C {
        default void run() {
            System.out.println("Hello from C");
        }

        ;
    }

    static class D {
        public void run() {
            System.out.println("Hello from D");
        }
    }

    static class E extends D implements A, B, C {
    }

    public static void main(String[] args) {
        E e = new E();
        e.run();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tjVhnE9S-1634828901579)(https://img-community.csdnimg.cn/images/7c1c469ac9f846fba67cc7ec143c0456.png “=600 #left”)]

codegym 练习 - 创建和使用数组

任务1 以相反顺序显示字符串数组

创建包含 10 个字符串的数组。
从键盘输入 8 个字符串并将其保存在数组中。
在屏幕上以相反顺序显示整个数组（10 个元素）的内容。每行显示一个元素。

package zh.codegym.task.task07.task0702;

import java.io.BufferedReader;
import java.io.InputStreamReader;

/* 
以相反顺序显示字符串数组
*/

public class Solution {
    public static void main(String[] args) throws Exception {
        String[] arr = new String[10];
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        for (int i = 0; i < 8 ; i++) {
            String s = reader.readLine();
            arr[i] = s;
        }

        for (int i = 9; i >=0 ; i--) {
            System.out.println(arr[i]);
        }
        //在此编写你的代码
    }
}

任务2 寂寞数组之间的互动

创建包含 10 个字符串的数组。
创建包含 10 个数字的数组。
从键盘输入 10 个字符串，然后将其放入字符串数组中
在数字数组的每个元素中，记录其字符串数组索引与数字数组当前索引一致的字符串的长度。

显示数字数组的内容，每行显示一个值。

package zh.codegym.task.task07.task0703;

import java.io.BufferedReader;
import java.io.InputStreamReader;

/* 
寂寞数组之间的互动
*/

public class Solution {
    public static void main(String[] args) throws Exception {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        int[] intArr = new int[10];
        String[] stringArr = new String[10];
        for (int i = 0; i < stringArr.length; i++) {
            String s = reader.readLine();
            stringArr[i] = s;
        }

        for (int i = 0; i < stringArr.length; i++) {
            intArr[i] = stringArr[i].length();
        }

        for (int x : intArr
                ) {
            System.out.println(x);
        }
        //在此编写你的代码
    }
}

任务3 一个大数组和两个小数组

创建包含 20 个数字的数组。
从键盘输入值来填充数组。
创建两个分别包含 10 个数字的数组。
将大数组复制到两个小数组中：一半数字复制到第一个小数组中，另一半数字复制到第二个小数组中。
显示第二个小数组，每行显示一个值。

package zh.codegym.task.task07.task0705;

import java.io.BufferedReader;
import java.io.InputStreamReader;

/* 
一个大数组和两个小数组
*/

public class Solution {
    public static void main(String[] args) throws Exception {
        int[] bigArr = new int[20];
        int[] smallArr1 = new int[10];
        int[] smallArr2 = new int[10];

        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        for (int i = 0; i < bigArr.length; i++) {
            int n = Integer.parseInt(reader.readLine());
            bigArr[i] = n;
        }

        for (int i = 0; i < smallArr1.length; i++) {
            smallArr1[i] = bigArr[i];
        }

        for (int i = 0; i < smallArr2.length; i++) {
            smallArr2[i] = bigArr[i + 10];
        }

        for (int x : smallArr2
                ) {
            System.out.println(x);
        }
    }
}

任务4 街道和房屋

创建包含 15 个整数的数组。
从键盘输入值来填充数组。
让数组索引表示门牌号。特定索引处的数组值表示居住在相应房屋中的人数。
门牌号为奇数的房屋位于街道的一侧。门牌号为偶数的房屋位于街道的另一侧。弄清街道哪一侧居住的居民较多。
显示以下消息：“居住在门牌号为奇数的房屋的居民更多。”或“居住在门牌号为偶数的房屋的居民更多。”

注意：
索引为 0 处的房屋门牌号视为偶数。
5.如果街道每侧的居民数量相同，则不输出任何内容。

package zh.codegym.task.task07.task0706;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/* 
街道和房屋
*/

public class Solution {
    public static void main(String[] args) throws Exception {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        int[] arr = new int[15];
        for (int i = 0; i < arr.length; i++) {
            int num = Integer.parseInt(reader.readLine());
            arr[i] = num;
        }

        int oddSum = 0;  //奇数门牌号总人数
        int evenSum = 0;  //偶数门牌号总人数

        //求总人数
        for (int i = 0; i < arr.length; i++) {
            if (i % 2 == 1) {
                oddSum += arr[i];
            }else{
                evenSum += arr[i];
            }
        }

        //比较
        if(oddSum > evenSum){
            System.out.println("居住在门牌号为奇数的房屋的居民更多。");
        }else if(oddSum < evenSum){
            System.out.println("居住在门牌号为偶数的房屋的居民更多。");
        }
    }
}

codegym 练习 - 创建和使用数组

任务1 那是什么类型的列表？

1.创建字符串列表。

2.向列表中添加 5 个不同的字符串。

3.在屏幕上显示列表大小。

4.使用循环显示列表内容，每行显示一个值。

注意：
仅在初始化列表后，再将字符串添加到列表中。

package zh.codegym.task.task07.task0707;

import java.util.ArrayList;

/* 
那是什么类型的列表？
*/

public class Solution {
    public static void main(String[] args) throws Exception {
        ArrayList<String> list = new ArrayList<String>(5);
        list.add("塔玛希");
        list.add("miao");
        list.add("喵");
        list.add("HarpyLady");
        list.add("青眼白龙");

        System.out.println(list.size());

        for (String s : list
                ) {
            System.out.println(s);
        }
    }
}

任务2 最长的字符串

1.初始化字符串列表。

2.从键盘读取 5 个字符串，并将其添加到此列e表中。

3.使用循环找出列表中最长的字符串。

4.显示字符串。如果有多个最长字符串，则每行显示一个。

Requirements:

在 main 方法中，将 Solution 类的现有字符串字段初始化为新的 ArrayList<>。
程序应从键盘读取 5 个字符串，并将其写入字符串列表中。
程序应显示最长的字符串。
如果有多个最长字符串，则需要每行显示一个。

package zh.codegym.task.task07.task0708;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

/* 
最长的字符串
*/

public class Solution {
    private static List<String> strings;

    public static void main(String[] args) throws Exception {
        strings = new ArrayList<String>(5);
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        int maxLenth = 0;
        ArrayList<String> longestStrings = new ArrayList<String>(5);

        //录入5个字符串，记录最大长度
        for (int i = 0; i < 5; i++) {
            String s = reader.readLine();
            if (s.length() > maxLenth) {
                maxLenth = s.length();
            }
            strings.add(s);
        }

        //遍历打印最长字符串
        for (String s : strings
                ) {
            if (s.length() == maxLenth) {
                System.out.println(s);
            }
        }
    }
}

任务3 更简洁地表达自己

1.创建字符串列表。

2.从键盘读取 5 个字符串并将其添加到列表中。

3.使用循环找出列表中最短的字符串。

4.显示字符串。

5.如果有多个最短字符串，则每行显示一个。

Requirements:

1. 声明字符串列表变量并立即初始化该变量。
2. 程序应从键盘读取 5 个字符串并将其写入列表中。
3. 程序应显示最短的字符串。
4. 如果有多个最短字符串，则需要每行显示一个。

package zh.codegym.task.task07.task0709;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;

/* 
更简洁地表达自己
*/

public class Solution {
    public static void main(String[] args) throws Exception {
        ArrayList<String> list = new ArrayList<String>(5);
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));


        //录入字符串
        for (int i = 0; i < 5; i++) {
            String s = reader.readLine();
            list.add(s);
        }

        //获取最短字符串长度
        int shortestLength = list.get(0).length();
        for (String s : list) {
            if (s.length() < shortestLength) {
                shortestLength = s.length();
            }
        }

        //遍历打印最短字符串
        for (String s : list) {
            if (s.length() == shortestLength) {
                System.out.println(s);
            }
        }
    }
}

任务4 到达列表顶部

1.在 main 方法中创建字符串列表。

2.从键盘向该列表中添加 10 个字符串，但只将其添加到列表开头而非末尾。

3.使用循环显示内容，每行显示一个值。

Requirements:

1. 声明字符串列表变量并立即初始化该变量。
2. 程序应从键盘读取 10 个字符串并将其添加到列表中。
3. 程序应向列表开头添加几行内容。
4. 程序应显示列表，每行显示一个值。

package zh.codegym.task.task07.task0710;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;

/* 
到达列表顶部
*/

public class Solution {
    public static void main(String[] args) throws Exception {
        ArrayList<String> list = new ArrayList<>(10);
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        //添加内字符串至列表开头
        for (int i = 0; i < 10; i++) {
            list.add(0, reader.readLine());
        }

        //遍历打印
        for (String s : list) {
            System.out.println(s);
        }
    }
}

任务 5 删除和插入

1.创建字符串列表。

2.从键盘添加 5 个字符串。

3.将以下操作执行 13 次：删除最后一个字符串，并将其插入开头位置。

4.使用循环显示生成的列表，每行显示一个值。

Requirements:

声明字符串列表变量并立即初始化该变量。
程序应从键盘读取 5 个字符串。
删除最后一个字符串，并将其插入开头位置。冲洗掉并重复 13 次。
程序应显示列表，每行显示一个值。

package zh.codegym.task.task07.task0711;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;

/* 
删除和插入
*/

public class Solution {
    public static void main(String[] args) throws Exception {
        ArrayList<String> list = new ArrayList<>(5);
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        for (int i = 0; i < 5; i++) {
            list.add(reader.readLine());
        }

        for (int i = 0; i < 13; i++) {
            String s = list.get(4);
            list.remove(4);
            list.add(0, s);
        }

        for (String s : list) {
            System.out.println(s);
        }
    }
}

任务6 最短或最长

1.创建字符串列表。

2.从键盘添加 10 个字符串。

3.找出列表中较早出现的字符串：最短的或最长的。

如果有多个字符串为最短或最长的字符串，则考虑遇到的第一个此类字符串。

4.显示第 3 步中描述的字符串。应显示一个字符串。

Requirements:

1. 声明字符串列表变量并立即初始化该变量。
1. 程序应从键盘读取 10 个字符串并将其添加到列表中。
1. 如果最短字符串在最长字符串之前出现，则程序应显示最短字符串。
1. 如果最长字符串在最短字符串之前出现，则程序应显示最长字符串。

package zh.codegym.task.task07.task0712;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

/* 
最短或最长
*/

public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            String s = reader.readLine();
            list.add(s);
        }

        String minSizeElement = list.get(0);
        int posMinElement = 0;
        String maxSizeElement = list.get(0);
        int posMaxElement = 0;
        for (int i = 0; i < 10; i++) {
            if (list.get(i).length() < minSizeElement.length()) {
                minSizeElement = list.get(i);
                posMinElement = i;
            } else if (list.get(i).length() > maxSizeElement.length()) {
                maxSizeElement = list.get(i);
                posMaxElement = i;
            }
        }

        if (posMinElement < posMaxElement) {
            System.out.println(minSizeElement);
        } else if (posMaxElement < posMinElement) {
            System.out.println(maxSizeElement);
        }
    }
}