Java学习笔记（新手纯小白向）
第一章 JAVA基础概念
第二章 JAVA安装和环境配置
第三章 IntelliJ IDEA安装
第四章 运算符
第五章 运算符联系
第六章 判断与循环
第七章 判断与循环练习
第八章 循环高级综合
第九章 数组介绍及其内存图
第十章 数组基础练习
第十一章 方法基础及简单应用
第十二章 方法基础练习
第十三章 前续知识综合练习
第十四章 面向对象基础
第十五章 面向对象综合训练
第十六章 字符串基础
第十七章 字符串基础练习
第十八章 ArrayList集合
第十九章 ArrayList集合基础练习
第二十章 面向对象进阶
第二十一章 面向对象进阶基础练习
目录
前言
本篇章主要展示了常见的一些基础的面向对象进阶知识练习及解答
一、员工
1.需求
在黑马程序员中有很多员工(Employee)。
按照工作内容不同分教研部员工(Teacher)和行政部员工(AdminStaff)
教研部根据教学的方式不同又分为讲师(Lecturer)和助教(Tutor)
行政部根据负责事项不同,又分为维护专员(Maintainer),采购专员(Buyer)
公司的每一个员工都编号,姓名和其负责的工作
每个员工都有工作的功能，但是具体的工作内容又不一样。
2.参考答案
java
public class Employee {
//定义员工的属性
private String id;
private String name;
//定义空参构造和带参构造
public Employee() {
}
public Employee(String id, String name) {
this.id = id;
this.name = name;
}
//定义成员变量的get和set方法
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//定义方法work，代表行为：工作
public void work() {
System.out.println("员工在工作");
}
}
java
public class AdminStaff extends Employee {
//定义空参构造和带参构造
public AdminStaff() {
}
public AdminStaff(String id, String name) {
super(id, name);
}
//重写方法work
@Override
public void work() {
System.out.println("行政部员工在进行行政工作");
}
}
java
public class MainTrainer extends AdminStaff {
//定义空参构造和带参构造
public MainTrainer() {
}
public MainTrainer(String id, String name) {
super(id, name);
}
//重写方法work
@Override
public void work() {
System.out.println("维护专员在进行维护");
}
}
java
public class Buyer extends AdminStaff {
//定义空参构造和带参构造
public Buyer() {
}
public Buyer(String id, String name) {
super(id, name);
}
//重写方法work
@Override
public void work() {
System.out.println("采购专员在采购");
}
}
java
public class Teacher extends Employee {
//定义空参构造和带参构造
public Teacher() {
}
public Teacher(String id, String name) {
super(id, name);
}
//重写方法work
@Override
public void work() {
System.out.println("教研部员工在进行教学任务");
}
}
java
public class Lecturer extends Teacher {
//定义空参构造和带参构造
public Lecturer() {
}
public Lecturer(String id, String name) {
super(id, name);
}
//重写方法work
@Override
public void work() {
System.out.println("讲师在讲课");
}
}
java
public class Tutor extends Teacher {
//定义空参构造和带参构造
public Tutor() {
}
public Tutor(String id, String name) {
super(id, name);
}
//重写方法work
@Override
public void work() {
System.out.println("助教在批改作业");
}
}
java
public class EmployeeTest {
//在黑马程序员中有很多员工(Employee)。
//按照工作内容不同分教研部员工(Teacher)和行政部员工(AdminStaff)
//教研部根据教学的方式不同又分为讲师(Lecturer)和助教(Tutor)
//行政部根据负责事项不同,又分为维护专员(Maintainer),采购专员(Buyer)
//公司的每一个员工都编号,姓名和其负责的工作
//每个员工都有工作的功能，但是具体的工作内容又不一样。
public static void main(String[] args) {
//创建对象
Lecturer l = new Lecturer("001", "zhangsan");
Tutor t = new Tutor("002", "lisi");
MainTrainer m = new MainTrainer("003", "wangwu");
Buyer b = new Buyer("004", "zhaoliu");
//调用方法
System.out.println(l.getId() + "," + l.getName());
l.work();
System.out.println(t.getId() + "," + t.getName());
t.work();
System.out.println(m.getId() + "," + m.getName());
m.work();
System.out.println(b.getId() + "," + b.getName());
b.work();
}
}二、角色
1.需求
在传智教育的tlias教学资源管理系统中，存在学生、老师角色会进入系统。
2.分析
学生信息和行为（名称，年龄，所在班级，查看课表，填写听课反馈fillForm）
老师信息和行为（名称，年龄，部门名称，查看课表，发布问题publishForm）
定义角色类作为父类包含属性（名称，年龄），行为（查看课表）
定义子类：学生类包含属性（所在班级），行为（填写听课反馈）
定义子类：老师类包含属性（部门名称），行为（发布问题）
3.参考答案
java
public class Role {
//定义角色的属性
private String name;
private int age;
//定义空参构造和带参构造
public Role() {
}
public Role(String name, int age) {
this.name = name;
this.age = age;
}
//定义成员变量的get和set方法
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;
}
//定义方法viewSchedule，代表行为：查看课表
public void viewSchedule() {
System.out.println("查看课表");
}
}
java
public class Teacher extends Role {
//定义老师的属性
private String department;
//定义空参构造和带参构造
public Teacher() {
}
public Teacher(String name, int age, String department) {
super(name, age);
this.department = department;
}
//定义成员变量的get和set方法
public String getDepartment() {
return department;
}
public void setDepartment(String department) {
this.department = department;
}
//定义方法publishForm，代表行为：发布问题
public void publishForm() {
System.out.println("发布问题");
}
}
java
public class Student extends Role {
//定义学生的属性
private String atClass;
//定义空参构造和带参构造
public Student() {
}
public Student(String name, int age, String atClass) {
super(name, age);
this.atClass = atClass;
}
//定义成员变量的get和set方法
public String getAtClass() {
return atClass;
}
public void setAtClass(String atClass) {
this.atClass = atClass;
}
//定义方法fillForm，代表行为：填写听课反馈
public void fillForm() {
System.out.println("填写听课反馈");
}
}
java
public class RoleTest {
//在传智教育的tlias教学资源管理系统中，存在学生、老师角色会进入系统。
public static void main(String[] args) {
//创建老师和学生对象
Student student1 = new Student("zhangsan", 23, "2203");
Teacher teacher1 = new Teacher("lisi", 34, "Java");
//打印信息，并调用方法
System.out.println(student1.getName() + "," + student1.getAge() + "," + student1.getAtClass());
student1.viewSchedule();
student1.fillForm();
System.out.println("------------------------------------------------");
System.out.println(teacher1.getName() + "," + teacher1.getAge() + "," + teacher1.getDepartment());
teacher1.viewSchedule();
teacher1.publishForm();
}
}三、手机
1.需求
完成代码(按照标准格式写)，然后在测试类中测试。
（1）手机类Phone
属性:品牌brand,价格price
无参构造,有参构造
行为:打电话call,发短信sendMessage,玩游戏playGame
（2）测试类
创建Phone类对象,调用Phone类中的方法
2.思考
假设所有的手机都有属性屏幕的尺寸(int size),而且假设所有手机的屏幕尺寸为6,应该如何实现?
3.提示
可以把size定义为静态
4.参考答案
java
public class Phone {
//定义手机的属性
private String brand;
private double price;
private static int size;
//定义空参构造和带参构造
public Phone() {
}
public Phone(String brand, double price) {
this.brand = brand;
this.price = price;
}
//定义成员变量的get和set方法
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public static int getSize() {
return size;
}
public static void setSize(int size) {
Phone.size = size;
}
//定义方法call，代表行为：打电话
public void call() {
System.out.println("打电话");
}
//定义方法sendMessage，代表行为：发短信
public void sendMessage() {
System.out.println("发短信");
}
//定义方法playGame，代表行为：玩游戏
public void playGame() {
System.out.println("玩游戏");
}
}
java
public class PhoneTest {
//完成代码(按照标准格式写)，然后在测试类中测试。
//1.手机类Phone
//属性:品牌brand,价格price
//无参构造,有参构造
//行为:打电话call,发短信sendMessage,玩游戏playGame
//2.测试类
//创建Phone类对象,调用Phone类中的方法
//假设所有的手机都有属性屏幕的尺寸(int size),而且假设所有手机的屏幕尺寸为6,应该如何实现?
public static void main(String[] args) {
//对手机屏幕尺寸进行赋值
Phone.setSize(6);
//创建手机对象
Phone phone1 = new Phone("xiaomi", 1999.99);
//打印信息，并调用方法
System.out.println(phone1.getBrand() + "," + phone1.getPrice() + "," + Phone.getSize());
phone1.call();
phone1.sendMessage();
phone1.playGame();
}
}四、人
1.需求
（1）定义Person类
属性：
姓名name、性别gender、年龄age、国籍nationality；
方法：
吃饭eat、睡觉sleep，工作work。
（2）根据人类，创建一个学生类Student
增加属性：
学校school、学号stuNumber；
重写工作方法（学生的工作是学习）。
（3）根据人类，创建一个工人类Worker
增加属性：
单位unit、工龄workAge；
重写工作方法（工人的工作是盖房子）。
（4）根据学生类，创建一个学生干部类 StudentLeader
增加属性：
职务job；
增加方法：开会meeting。
（5）编写测试类分别对上述3类具体人物进行测试。
（6）要求运行结果:
学生需要学习!
工人的工作是盖房子!
学生干部喜欢开会!
2.参考答案
java
public class Person {
//定义人的属性
private String name;
private String gender;
private int age;
private String nationality;
//定义空参构造和带参构造
public Person() {
}
public Person(String name, String gender, int age, String nationality) {
this.name = name;
this.gender = gender;
this.age = age;
this.nationality = nationality;
}
//定义成员变量的get和set方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getNationality() {
return nationality;
}
public void setNationality(String nationality) {
this.nationality = nationality;
}
//定义方法eat，代表行为：吃饭
public void eat() {
System.out.println("人类要工作");
}
//定义方法sleep，代表行为：睡觉
public void sleep() {
System.out.println("人类要睡觉");
}
//定义方法work，代表行为：工作
public void work() {
System.out.println("人类要工作");
}
}
java
public class Worker extends Person {
//定义工人的属性
private String unit;
private double workAge;
//定义空参构造和带参构造
public Worker() {
}
public Worker(String name, String gender, int age, String nationality, String unit, double workAge) {
super(name, gender, age, nationality);
this.unit = unit;
this.workAge = workAge;
}
//定义成员变量的get和set方法
public String getUnit() {
return unit;
}
public void setUnit(String unit) {
this.unit = unit;
}
public double getWorkAge() {
return workAge;
}
public void setWorkAge(double workAge) {
this.workAge = workAge;
}
//重写方法work
@Override
public void work() {
System.out.println("工人的工作是盖房子！");
}
}
java
public class Student extends Person {
//定义学生的属性
private String school;
private String stuNumber;
//定义空参构造和带参构造
public Student() {
}
public Student(String name, String gender, int age, String nationality, String school, String stuNumber) {
super(name, gender, age, nationality);
this.school = school;
this.stuNumber = stuNumber;
}
//定义所有成员变量的get和set方法
public String getSchool() {
return school;
}
public void setSchool(String school) {
this.school = school;
}
public String getStuNumber() {
return stuNumber;
}
public void setStuNumber(String stuNumber) {
this.stuNumber = stuNumber;
}
//重写方法work
@Override
public void work() {
System.out.println("学生需要学习！");
}
}
java
public class StudentLeader extends Student {
//定义学生干部的属性
private String job;
//定义空参构造和带参构造
public StudentLeader() {
}
public StudentLeader(String name, String gender, int age, String nationality, String school, String stuNumber, String job) {
super(name, gender, age, nationality, school, stuNumber);
this.job = job;
}
//定义成员变量的get和set方法
public String getJob() {
return job;
}
public void setJob(String job) {
this.job = job;
}
//定义方法meeting，代表行为：开会
public void meeting() {
System.out.println("学生干部喜欢开会！");
}
}
java
public class PersonTest {
//分析以下需求，并用代码实现
//1.定义Person类
//属性：
//姓名name、性别gender、年龄age、国籍nationality；
//方法：
//吃饭eat、睡觉sleep，工作work。
//2.根据人类，创建一个学生类Student
//增加属性：
//学校school、学号stuNumber；
//重写工作方法（学生的工作是学习）。
//3.根据人类，创建一个工人类Worker
//增加属性：
//单位unit、工龄workAge；
//重写工作方法（工人的工作是盖房子）。
//4.根据学生类，创建一个学生干部类 StudentLeader
//增加属性：
//职务job；
//增加方法：开会meeting。
//5.编写测试类分别对上述3类具体人物进行测试。
//6.要求运行结果:
//学生需要学习!
//工人的工作是盖房子!
//学生干部喜欢开会!
public static void main(String[] args) {
//创建对象
Student student = new Student("zhangsan", "man", 23, "China", "岳麓书院", "c001");
Worker worker = new Worker("lisi", "woman", 46, "China", "中建七局", 12.3);
StudentLeader studentLeader = new StudentLeader("wangwu", "man", 24, "US", "MIT", "u001", "leader");
//调用方法，打印结果
student.work();
worker.work();
studentLeader.meeting();
}
}五、员工
1.需求
（1）定义项目经理类 属性： 姓名 工号 工资 奖金 行为： 工作work
（2）定义程序员类 属性： 姓名 工号 工资 行为： 工作work
（3）向上抽取一个父类,让这两个类都继承这个父类,共有的属性写在父类中，子类重写父类中的方法
（4）编写测试类:完成这两个类的测试
2.参考答案
java
public class Employee {
//定义员工的属性
private String name;
private String id;
private double salary;
//定义空参构造和带参构造
public Employee() {
}
public Employee(String name, String id, double salary) {
this.name = name;
this.id = id;
this.salary = salary;
}
//定义成员变量的get和set方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
//定义方法work，代表行为：工作
public void work() {
System.out.println("员工在工作");
}
}
java
public class Manager extends Employee {
//定义项目经理的属性
private double bonus;
//定义空参构造和带参构造
public Manager() {
}
public Manager(String name, String id, double salary, double bonus) {
super(name, id, salary);
this.bonus = bonus;
}
//定义成员变量的get和set方法
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
//重写方法work
public void work() {
System.out.println("项目经理正在增加需求");
}
}
java
public class Programmer extends Employee {
//定义空参构造和带参构造
public Programmer() {
}
public Programmer(String name, String id, double salary) {
super(name, id, salary);
}
//重写方法work
public void work() {
System.out.println("程序员正在更改需求");
}
}
java
public class EmployeeTest {
//1.定义项目经理类 属性： 姓名 工号 工资 奖金 行为： 工作work
//2.定义程序员类 属性： 姓名 工号 工资 行为： 工作work
//3.向上抽取一个父类,让这两个类都继承这个父类,共有的属性写在父类中，子类重写父类中的方法
//4.编写测试类:完成这两个类的测试
public static void main(String[] args) {
//创建对象
Manager manager = new Manager("zhangsan", "001", 19999.9, 39999.9);
Programmer programmer = new Programmer("lisi", "002", 29999.9);
//打印信息，并调用方法
System.out.println(manager.getName() + "," + manager.getId() + "," + manager.getSalary() + "," + manager.getBonus());
manager.work();
System.out.println("------------------------------------------");
System.out.println(programmer.getName() + "," + programmer.getId() + "," + programmer.getSalary());
programmer.work();
}
}六、人与动物
1.需求
（1）定义动物类
属性： 年龄，颜色
行为: eat(String something)方法(无具体行为,不同动物吃的方式和东西不一样,something表示吃的东西)
生成空参有参构造，set和get方法
（2）定义狗类继承动物类
行为: eat(String something)方法,看家lookHome方法(无参数)
（3）定义猫类继承动物类
行为:eat(String something)方法,逮老鼠catchMouse方法(无参数)
（4）定义Person类
属性： 姓名，年龄
行为1： keepPet(Dog dog,String something)方法
功能1：喂养宠物狗，something表示喂养的东西
该方法调用后打印结果为：颜色为黑色的2岁的狗，在吃骨头
行为2： keepPet(Cat cat,String something)方法
功能2：喂养宠物猫，something表示喂养的东西
该方法调用后打印结果为：颜色为白色的2岁的猫，在吃小鱼干
（5）生成空参有参构造，set和get方法
（6）测试以上方法
2.参考答案
java
public class Animal {
//定义动物的属性
private int age;
private String color;
//定义空参构造和带参构造
public Animal() {
}
public Animal(int age, String color) {
this.age = age;
this.color = color;
}
//定义成员变量的get和set方法
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
//定义方法eat，代表行为：吃
public String eat(String sth) {
return "在吃" + sth;
}
}
java
public class Cat extends Animal {
//定义空参构造和带参构造
public Cat() {
}
public Cat(int age, String color) {
super(age, color);
}
//重写方法eat
@Override
public String eat(String sth) {
return "喵喵喵地舔着吃" + sth;
}
//定义方法catchMouse，代表行为：逮老鼠
public void catchMouse() {
System.out.println("猫在逮老鼠");
}
}
java
public class Dog extends Animal {
//定义空参构造和带参构造
public Dog() {
}
public Dog(int age, String color) {
super(age, color);
}
//重写方法eat
@Override
public String eat(String sth) {
return "汪汪汪地咬着吃" + sth;
}
//定义方法lookHome，代表行为：看家
public void lookHome() {
System.out.println("狗在看家");
}
}
java
public class Person {
//定义人的属性
private String name;
private int age;
//定义空参构造和带参构造
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
//定义成员变量的get和set方法
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;
}
//定义方法keepPet，代表行为：喂养宠物狗
public void keepPet(Dog dog, String sth) {
System.out.println("颜色为" + dog.getColor() + "的" + dog.getAge() + "岁的狗，" + dog.eat(sth));
}
//定义方法keepPet，代表行为：喂养宠物猫
public void keepPet(Cat cat, String sth) {
System.out.println("颜色为" + cat.getColor() + "的" + cat.getAge() + "岁的猫，" + cat.eat(sth));
}
}
java
public class AnimalTest {
//根据需求完成代码:
//1.定义动物类
//属性： 年龄，颜色 行为: eat(String something)方法(无具体行为,不同动物吃的方式和东西不一样,something表示吃的东西)
//生成空参有参构造，set和get方法
//2.定义狗类继承动物类
//行为: eat(String something)方法,看家lookHome方法(无参数)
//3.定义猫类继承动物类
//行为:
//eat(String something)方法,逮老鼠catchMouse方法(无参数)
//4.定义Person类
//属性： 姓名，年龄
//行为： keepPet(Dog dog,String something)方法
//功能：喂养宠物狗，something表示喂养的东西
//该方法调用后打印结果为：颜色为黑色的2岁的狗，在吃骨头
//行为： keepPet(Cat cat,String something)方法 功能：喂养宠物猫，something表示喂养的东西
//该方法调用后打印结果为：颜色为白色的2岁的猫，在吃小鱼干
//5.生成空参有参构造，set和get方法
//6.测试以上方法
public static void main(String[] args) {
//创建对象
Dog dog = new Dog(2, "黑色");
Cat cat = new Cat(3, "白色");
Person person = new Person("zhangsan", 23);
//打印信息，并调用方法
System.out.println(person.getName() + "," + person.getAge());
System.out.println(dog.getAge() + "," + dog.getColor());
person.keepPet(dog, "骨头");
System.out.println(cat.getAge() + "," + cat.getColor());
person.keepPet(cat, "小鱼干");
}
}七、面积与周长
1.需求
（1）定义形状类:
功能：求面积，求周长
（2）定义圆形类Round:
属性：半径，圆周率
功能：求面积，求周长
（3）定义长方形类Rectangle:
属性：长和宽
功能：求面积，求周长
（4）定义测试类:
分别创建圆形和长方形对象，为相应的属性赋值
分别调用求面积和求周长的方法
2.参考答案
java
public abstract class Shape {
//定义空参构造
public Shape() {
}
//定义抽象方法getArea，表示行为求面积
public abstract double getArea();
//定义抽象方法getPerimeter，表示行为求周长
public abstract double getPerimeter();
}
java
public class Rectangle extends Shape {
//定义长方形的属性
private double length;
private double width;
//定义空参构造和带参构造
public Rectangle() {
}
public Rectangle(double length, double width) {
this.length = length;
this.width = width;
}
//定义所有成员变量的get和set方法
public double getLength() {
return length;
}
public void setLength(double length) {
this.length = length;
}
public double getWidth() {
return width;
}
public void setWidth(double width) {
this.width = width;
}
@Override
public double getArea() {
return length * width;
}
@Override
public double getPerimeter() {
return 2 * (length + width);
}
}
java
public class Round extends Shape {
//定义圆形的属性
private double radius;
private final double pi = 3.14;
//定义空参构造和带参构造
public Round() {
}
public Round(double radius) {
this.radius = radius;
}
//定义成员变量的get和set方法
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
public double getPi() {
return pi;
}
@Override
public double getArea() {
return pi * (radius * radius);
}
@Override
public double getPerimeter() {
return 2 * pi * radius;
}
}
java
//需求
/*定义形状类:
功能：求面积，求周长
定义圆形类Round:
属性：半径，圆周率
功能：求面积，求周长
定义长方形类Rectangle:
属性：长和宽
功能：求面积，求周长
定义测试类:
分别创建圆形和长方形对象，为相应的属性赋值
分别调用求面积和求周长的方法*/
public class Test {
public static void main(String[] args) {
//创建圆形对象
Round r1 = new Round(2);
//调用方法，求面积与周长
System.out.println("圆形的面积为：" + r1.getArea());
System.out.println("圆形的周长为：" + r1.getPerimeter());
//创建长方形对象
Rectangle r2 = new Rectangle(4, 2);
//调用方法，求面积与周长
System.out.println("长方形的面积为：" + r2.getArea());
System.out.println("长方形的周长为：" + r2.getPerimeter());
}
}八、新旧手机
1.需求
（1）定义手机类
行为：打电话,发短信
（2）定义接口IPlay
行为：玩游戏
（3）定义旧手机类继承手机类
行为：继承父类的行为
（4）定义新手机继承手机类实现IPlay接口
行为：继承父类的行为,重写玩游戏方法
（5）定义测试类
在测试类中定义一个 用手机的方法,要求该方法既能接收老手机对象,也能接收新手机对象
在该方法内部调用打电话,发短信以及新手机特有的玩游戏方法
2.参考答案
java
public class Phone {
//定义空参构造
public Phone() {
}
//定义方法call，代表行为：打电话
public void call() {
System.out.println("用手机打电话");
}
//定义方法message，代表行为：发短信
public void message() {
System.out.println("用手机发短信");
}
}
java
public class OldPhone extends Phone {
}
java
public class NewPhone extends Phone implements IPlay {
@Override
public void playGame() {
System.out.println("用新手机玩游戏");
}
}
java
public interface IPlay {
//定义抽象方法playGame，代表行为：玩游戏
public abstract void playGame();
}
java
//需求
/*定义手机类
行为：打电话,发短信
定义接口IPlay
行为：玩游戏
定义旧手机类继承手机类
行为：继承父类的行为
定义新手机继承手机类实现IPlay接口
行为：继承父类的行为,重写玩游戏方法
定义测试类
在测试类中定义一个用手机的方法,要求该方法既能接收老手机对象,也能接收新手机对象
在该方法内部调用打电话,发短信以及新手机特有的玩游戏方法*/
public class Test {
public static void main(String[] args) {
//使用多态，创建新手机对象和老手机对象
Phone p1 = new OldPhone();
Phone p2 = new NewPhone();
usePhone(p1);
usePhone(p2);
}
//定义方法usePhone，代表行为：用手机
public static void usePhone(Phone p) {
p.call();
p.message();
if (p instanceof NewPhone) {
((NewPhone) p).playGame();
}
}
}九、匿名内部类调用方法
1.需求
（1）接口IPlay中有一个方法playGame()，在测试类中如何调用该方法？
要求1.创建子类实现接口的方式实现 要求2:用匿名内部类实现
（2）一个抽象类Fun中有一个抽象方法 fun() , 在测试类中如何调用该方法?
要求1.创建子类继承抽象类的方式实现 要求2:用匿名内部类实现
2.参考答案
java
public interface IPlay {
public abstract void playGame();
}
java
public abstract class Fun {
public abstract void fun();
}
java
public class Zi extends Fun implements IPlay {
@Override
public void playGame() {
System.out.println("玩游戏");
}
@Override
public void fun() {
System.out.println("子类继承抽象类的方式实现fun方法");
}
}
java
//需求
/*接口IPlay中有一个方法playGame()，在测试类中如何调用该方法？
要求1.创建子类实现接口的方式实现 要求2:用匿名内部类实现
一个抽象类Fun中有一个抽象方法 fun() , 在测试类中如何调用该方法?
要求1.创建子类继承抽象类的方式实现 要求2:用匿名内部类实现*/
public class Test {
public static void main(String[] args) {
//使用创建子类实现接口的方式，在测试类中调用方法playGame()
Zi z1 = new Zi();
z1.playGame();
//用匿名内部类实现
new IPlay() {
@Override
public void playGame() {
System.out.println("用匿名内部类实现playGame方法");
}
}.playGame();
//使用创建子类继承抽象类的方式，在测试类中调用方法fun()
Zi z2 = new Zi();
z2.fun();
//用匿名内部类实现
new Fun() {
@Override
public void fun() {
System.out.println("用匿名内部类实现fun方法");
}
}.fun();
}
}十、输出"HelloWorld"
1.需求
在控制台输出"HelloWorld"
自己书写，不要用idea自动生成。
interface Inter {
void show();
}
class Outer {
//补齐代码
}
public class OuterDemo {
public static void main(String[] args) {
Outer.method().show();
}
}
2.参考答案
java
//需求
//在控制台输出"HelloWorld"
interface Inter {
void show();
}
class Outer {
//补齐代码
public static Inter method() {
return new Inter() {
@Override
public void show() {
System.out.println("HelloWorld");
}
};
}
}
public class OuterDemo {
public static void main(String[] args) {
Outer.method().show();
}
}十一、创建对象并调用成员方法1
1.需求
在测试类Test中创建A的对象a并调用成员方法methodA(),要求用两种方式实现
自己书写，不要用idea自动生成。
public class Test {
public static void main(String[] args) {
}
}
//定义接口
interface InterA {
void showA();
}
class A {
public void methodA(InterA a) {
a.showA();
}
}
2.参考答案
java
//需求
//在测试类Test中创建A的对象a并调用成员方法methodA(),要求用两种方式实现
public class Test {
public static void main(String[] args) {
//创建A的对象a并调用成员方法methodA()
A a = new A();
InterA a1 = new InterA() {
@Override
public void showA() {
System.out.println("第一种方式，重写showA方法");
}
};
//第一种方式传入对象a1，第二种方式传入对象a
a.methodA(a1);
}
}
//定义接口
interface InterA {
void showA();
}
class A implements InterA {
public void methodA(InterA a) {
a.showA();
}
@Override
public void showA() {
System.out.println("第二种方式，重写showA方法");
}
}十二、创建对象并调用成员方法2
1.需求
在测试类Test中创建B的对象b，并调用成员方法methodB
自己书写，不要用idea自动生成。
public class Test {
public static void main(String[] args) {
}
}
//定义一个接口
interface InterB {
void showB();
}
//目标：调用成员方法methodB
class B {
InterB b;
public B(InterB b){
this.b = b;
}
public void methodB(){
b.showB();
}
}
2.参考答案
java
//需求
//在测试类Test中创建B的对象b，并调用成员方法methodB
public class Test {
public static void main(String[] args) {
B b = new B(new InterB() {
@Override
public void showB() {
System.out.println("传入形参为InterB类型");
}
});
b.methodB();
}
}
//定义一个接口
interface InterB {
void showB();
}
//目标：调用成员方法methodB
class B {
InterB b;
public B(InterB b) {
this.b = b;
}
public void methodB() {
b.showB();
}
}总结
在了解了面向对象进阶的基础知识后，一定要自己独立动手练习代码，为以后的进阶打好基础。学习好面向对象的编程思想，会极大提高代码的复用性和可读性。