java学习笔记16（封装、访问权限修饰符、Arrlist 类、接口练习、数组练习、 ArrayList 练习）
文章目录
- 10.21
- 学习内容
-
- 小 tips 几则
-
- Shift + Enter
- markdown中的\` + \`
- 英文数字间距
- 封装
-
- 导入类
-
- 冲突
- 访问权限修饰符
-
- public
- private
- 有关代码风格
- `ArrayList` 类
-
- 优势
- 使用方法
-
- 创建容器
- 获取元素的数量
- 获取指定元素
- 将元素写入数组的指定位置
- 工作内容
-
- 任务1
- 任务2
- 任务2
- 任务3
- codegym 练习 - 创建和使用数组
-
- 任务1 以相反顺序显示字符串数组
- 任务2 寂寞数组之间的互动
- 任务3 一个大数组和两个小数组
- 任务4 街道和房屋
- codegym 练习 - 创建和使用数组
-
- 任务1 那是什么类型的列表？
- 任务2 最长的字符串
- 任务3 更简洁地表达自己
- 任务4 到达列表顶部
- 任务 5 删除和插入
- 任务6 最短或最长
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:
-
- 声明字符串列表变量并立即初始化该变量。
-
- 程序应从键盘读取 10 个字符串并将其添加到列表中。
-
- 如果最短字符串在最长字符串之前出现，则程序应显示最短字符串。
-
- 如果最长字符串在最短字符串之前出现，则程序应显示最长字符串。
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);
}
}
}