首页 > 分享 > Java面向对象

Java面向对象

萌宠菠菠乐园
2024-10-04 22:33

第1关：通关任务一
任务描述
本关任务：按要求编写一个Java应用程序，巩固Java面向对象知识。
相关知识
为了完成本关任务，我们回顾一下前面所学知识：1.面向对象思想；2.封装；3.继承；4.构造函数；5.super()和this()。
面向对象思想
构造器：new就是一个构造器，作用是：①分配空间；②赋初始值（避免错误，简化输入）；
new Object(Parameters)构造器调用构造函数，传参为了赋初始值；
对象的基本元素是：属性和方法类成员（属性和方法）。属性最为重要，属性的集合是一个状态，方法是一个状态到另一个状态的桥梁；
封装：属性和处理属性的方法集合起来。把数据及数据的操作方法放在一起，作为一个相互依存的整体，即对象。
面向对象是基于面向过程而言的，面向对象是将功能等通过对象来实现，将功能封装进对象之中，让对象去实现具体的细节；这种思想是将数据作为第一位，而方法或者说是算法作为其次，这是对数据一种优化，操作起来更加的方便，简化了过程。
封装
访问权限的控制常被称为是具体实现的隐藏。把数据和方法包装进类中，以及具体实现的隐藏共同被称为封装。
在这里插入图片描述
public：可以被所有其他类访问；
protected：自身、子类、及同一个包中类（接受包外的子类访问）；
default：同一包中的类可以访问，声明时没有加修饰符，认为是friendly（拒绝一切外包访问）；
private：只能被自己访问和修改。
类的访问控制符只有三种：public、private、protected
default是无访问控制符。
继承
在一个子类被创建的时候，首先会在内存中创建一个父类对象，然后在父类对象外部放上子类独有的属性，两者合起来形成一个子类的对象。继承使子类拥有父类所有的属性和方法，但是父类对象中的私有属性和方法，子类是无法访问到的，只是拥有，但不能使用。子类不能继承父类的构造函数，只是显式或隐式调用，可以从子类调用超类的构造函数。
用new创建子类的对象时，若子类没有带参构造函数，将先执行父类的无参构造函数，然后再执行自己的构造函数。父类定义了有参的构造函数后，可以不定义无参的构造函数，系统也不会提供默认的无参构造函数。这时子类只能调用父类的有参构造函数。
Java类是单继承，Java接口可以多继承。类可以实现多个接口，接口可以继承（扩展）多个接口。先继承后实现接口。
组合和继承
组合是指在新类里面创建原有的类的对象，重复利用已有类的功能。（“has - a”）
组合和继承都允许在新的类中设置子对象，只是组合是显式的，而继承是隐式的。组合中的整体类和继承中的子类对应，组合中的局部类和继承中的父类对应。
组合和继承的选择规则：
① 除非两个类之间是“is - a”的关系，否则不要轻易地使用继承。过多的使用继承会破坏代码的可维护性，当父类修改时，会影响所有继承他的子类，增加了程序维护的难度和成本。
②不要仅仅为实现多态而使用继承，如果类之间没有“is - a”关系，可以通过实现接口与组合的方式来达到相同的目的。
构造函数
用来在对象实例化时初始化对象的成员变量。
特点：
① 方法名必须和类名相同，不能有返回值（也不能为void）；
② 一个类可以有多个构造函数，没有定义的话，编译器会在源代码编译成字节码文件的过程中会提供一个没有参数的默认的构造方法。若定义后，不会再创建默认的构造方法；
③构造函数的参数有（0到多个）；
④构造函数在对象实例化时会被自动调用，且只运行一次；普通方法是在程序执行到时才调用且可以被该对象调用多次；
⑤构造函数的作用是完成对象的初始化；
⑥构造函数不能被继承，不能被覆盖，能被重载；
⑦子类可以通过super()关键字来显示调用父类的构造函数，父类没有提供无参构造，子类的构造函数中必须显式得调用父类的构造函数；
⑧父类和子类都没有定义构造函数时，编译器都会为父类生成一个默认的无参构造，给子类也生成一个默认的无参的构造函数；
⑨构造方法会在成员变量之后初始化；
⑩构造方法不能被static、final、synchronize、abstract、native修饰，但可以被public、private、protect修饰。
在继承的时候，父类当然也有构造方法，如果你要创建子类的对象，那么执行的过程首先是调用父类的无参构造方法生成父类的对象，然后再调用子类的无参构造方法来生成子类对象。继承的时候都是先生成父类的对象，然后再生成子类的对象。
通过使用this关键字带上参数，可以在一个构造函数中调用另外一个构造函数。这是this除了单纯表示“当前对象”(注意是针对对象而不是类的概念)之外的第二个作用。但是注意3点:
① 必须放在第一行；
②只能调用一个其它的构造函数。(也许可以这样理解，正是因为有了第一点，如果可以调用多个的话，那么就无法放在“第一行”，所以只能允许一次调用)；
③只能是构造函数调用构造函数，普通函数无法调用构造函数。
super()和this()
super()关键字表示超类的意思，当前类是从超类继承而来。
this表示当前对象；
只有在重写(Override)父类的方法中，子类要调用继承自父类的方法，才使用super关键字。
使用super()或者this()方法是必须放在构造函数的第一行；
由于this函数指向的构造函数默认有super()方法，所以规定this()和super()不能同时出现在一个构造函数中。
因为static方法或者语句块没有实例时可以使用，而此时不需要构造实例，所以不能用this()和super()。
编程要求
根据提示，在右侧编辑器Begin-End处补充代码：
声明一个抽象类Pet，封装属性name和sex，声明一个带有两个参数的构造函数，声明抽象方法void talk()和void eat()；
声明一个Dog类继承自Pet，封装属性color，声明带有三个参数的构造函数，复写talk()和eat()方法；
声明一个Cat类继承自Pet，封装属性weight，声明带有三个参数的构造函数，复写talk()和eat()方法；
编写测试类，通过有参构造函数实例化Dog类对象，调用talk()方法和eat()方法；通过有参构造函数实例化Cat类对象，调用talk()方法和eat()方法；
具体输出要求请看测试说明。
测试说明
测试输入：
泰迪
male
brown
波斯猫
male
2.5
预期输出：
名称：泰迪，性别：male，颜色：brown，汪汪叫
泰迪吃骨头！
名称：波斯猫，性别：male，体重：2.5kg，喵喵叫
波斯猫吃鱼！
开始你的任务吧，祝你成功！
参考代码：

package case1; import java.util.Scanner; public class Task1 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);String dogName = sc.next();String dogSex = sc.next();String dogColor = sc.next();String catName = sc.next();String catSex = sc.next();double catWeight = sc.nextDouble();Pet dog=new Dog(dogName,dogSex,dogColor); dog.talk(); dog.eat();Pet cat=new Cat(catName,catSex,catWeight);cat.talk();cat.eat();} } abstract class Pet { String name; String sex;abstract void talk();abstract void eat(); } class Dog extends Pet {private String color;public Dog(String name,String sex,String color){this.name=name;this.sex=sex;this.color=color;}void talk(){ System.out.println("名称："+name+"，性别："+sex+"，颜色："+color+"，汪汪叫");}void eat(){System.out.println(name+"吃骨头！");} } class Cat extends Pet { private double weight;public Cat(String name,String sex,double weight){this.name=name;this.sex=sex;this.weight=weight;}void talk(){ System.out.println("名称："+name+"，性别："+sex+"，体重："+weight+"kg，喵喵叫");}void eat(){System.out.println(name+"吃鱼！");} }

第2关：通关任务二
任务描述
本关任务：按要求编写一个Java应用程序，巩固Java封装、继承和多态的知识。
相关知识
为了完成本关任务，你需要掌握：1.重写和重载；2.abstract(抽象类)和interface(接口)；3.final关键字；4.static关键字；5.多态。
重写和重载
方法重载（overload）：
必须是同一个类；
方法名（也可以叫函数）一样；
参数类型不一样或参数数量或顺序不一样；
不能通过返回值来判断重载。
方法的重写（override）子类重写了父类的同名方法，两同两小一大原则：
方法名相同，参数类型相同；
子类返回类型是父类返回类型的子类；
子类抛出异常小于等于父类方法抛出异常；
子类访问权限大于等于父类方法访问权限。
在这里插入图片描述
在重写中，运用的是动态单分配，根据new的类型确定对象，从而确定调用的方法；
在重载中，运用的是静态多分配，根据静态类型确定对象，不能根据new的类型确定调用方法；
多态中，Father f = new Son()。
成员变量：编译运行参考左边；
成员函数：编译看左边，运行看右边；
静态函数：编译运行看左边。
abstract(抽象类)和interface(接口)
抽象类
用abstract修饰的类表示抽象类，抽象类位于继承树的抽象层，抽象类不能被实例化。
用abstract修饰的方法表示抽象方法，抽象方法没有方法体。抽象方法用来描述系统具有什么功能，但不提供具体的实现，把具体实现留给继承该类的子类。
抽象类特点：
含有抽象方法的类必须声明为抽象类（不管其中是否有其他方法）；
抽象类可以没有抽象方法，可以有普通方法；
抽象类必须被继承，抽象方法必须被重写（若子类还是抽象类，不需要重写）；
抽象类不能被实例化（不能直接构造一个该类的对象）。
抽象方法特点：
在类中没有方法体（抽象方法只需声明，而不需实现某些功能）；
抽象类中的抽象方法必须被实现；
如果一个子类没有实现父类中的抽象方法，则子类也变成了一个抽象类。
接口
interface 中的方法默认为public abstract （public、abstract可以省略），变量默认为public static final；类中的方法全部都是抽象方法。只有声明没有实现，在不同类中有不同的方法实现。
不同点：
接口中只能包含抽象方法和默认方法，不能为普通方法提供方法实现；抽象类中可以包含普通方法；
接口里不能定义静态方法（jdk1.8下可以定义static方法），抽象类可以定义静态方法；
接口中只能定义静态常量，不能定义普通成员变量；抽象类即可以定义变量又可以定义静态常量；
接口中不包含构造器，抽象类里可以包含构造器，抽象类中的构造器并不是用于创建对象，而是让其他子类调用这些构造器来完成抽象类的初始化操作；
接口里不能包含初始化块，但抽象类可以包含；
一个类最多只能有一个父类，包括抽象类；但一个类可以直接实现多个接口，通过实现多个接口可以弥补Java单继承的不足。
共同点：
接口和抽象类都不能被实例化，都位于继承树的顶端，用于被其他类实现的继承；
接口和抽象类都可以包含抽象方法，实现接口和继承抽象类的普通子类都必须实现这些方法。
在这里插入图片描述
final关键字
final修饰的类，就是最终类，不能被继承。
final修饰的方法，就是最终方法，最终方法不能被重写。
final修饰一个引用变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。修饰基本数据类型变量时，内容不能变。
final成员变量必须在初始化代码块或在构造器中初始化。
作用：
final类：如果一个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会再被扩展，那么就设计成final类。
final方法：①把方法锁定，防止任何继承类修改它的意义和实现。②高效，编译器在遇到调用final方法时候会转入内嵌机制，大大提升执行效率。
static关键字
static修饰的变量称为静态变量，静态变量属于整个类，而局部变量属于方法，只在该方法内有效。static不能修饰局部变量。static方法内部不能调用非静态方法。
静态变量只能在类主体中定义，不能在方法中定义；
static变量只会创建一份，不管创建几个对象，都共用一个变量。
类方法指被static修饰的方法，无this指针。其他的就是实例方法。类方法可以调用其他类的static方法。
类方法和对象方法的区别：
1、类方法是属于整个类的，而实例方法是属于类的某个对象的。
由于类方法是属于整个类的，并不属于类的哪个对象，所以类方法的方法体中不能有与类的对象有关的内容。即类方法体有如下限制：
类方法中不能引用对象变量；
类方法中不能调用类的对象方法；
在类方法中不能使用super、this关键字。（this表示当前类的对象，由static修饰的方法是类直接调用，不需要创建对象，所以不能用this）；

类方法不能被覆盖。
2、与类方法相比，对象方法几乎没有什么限制：
对象方法中可以引用对象变量，也可以引用类变量；
对象方法中可以调用类方法；
对象方法中可以使用super、this关键字。
static关键字的作用
为某特定数据类型或对象分配单一的存储空间，而与创建对象的个数无关；实现某个方法或属性与类而不是对象关联在一起；
静态变量属于类，在内存中只有一个复制，只要静态变量所在的类被加载，这个静态变量就会被分配空间。
多态
定义：不同类的对象对同一消息做出响应。同一消息可以根据发送对象的不同而采用多种不同的行为方式；
多态存在的三个必要条件：继承、重写、父类引用指向子类对象；
Java中多态的实现方式：接口实现，继承父类进行方法重写，同一个类中进行方法重载；
父类引用指向子类对象，该引用不能再访问子类新增的成员。Animal cat = new Cat()与直接new一个父类实例(Animal a = new Animal())的区别？
答：当父类是接口和抽象类时，不能实例化，只能运用多态，向上转型。普通类中，可以在子类中重写父类中的方法，这样就可以访问子类中的重写方法。
编程要求
按照要求编写一个Java应用程序：
定义一个抽象类Person，包含抽象方法eat()，封装属性name、sex、age，声明包含三个参数的构造方法；
定义一个Chinese类，继承自Person类，重写父类的eat()方法，并定义一个自己特有的方法shadowBoxing()；
定义一个English类，继承自Person类，重写父类的eat()方法，并定义一个自己特有的方法horseRiding()；
编写测试类，定义一个showEat()方法，使用父类作为方法的形参，实现多态，分别调用showEat()方法，通过强制类型转换调用各自类特有的方法；
具体输出要求请看测试说明。
测试说明
测试输入：
张三
男
20
史蒂文
男
22
预期输出：
姓名：张三，性别：男，年龄：20，我是中国人，我喜欢吃饭!
姓名：史蒂文，性别：男，年龄：22，我是英国人，我喜欢吃三明治!
张三在练习太极拳!
史蒂文在练习骑马！
开始你的任务吧，祝你成功！
参考代码：

package case2; import java.util.Scanner; public class Task2 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);String cName = sc.next();String cSex = sc.next();int cAge = sc.nextInt();String eName = sc.next();String eSex = sc.next();int eAge = sc.nextInt();Person test; Person person1=new Chinese(cName,cSex,cAge);showEat(person1);Person person2=new English(eName,eSex,eAge);showEat(person2); Chinese d=(Chinese)person1; d.shadowBoxing(); English e=(English)person2; e.horseRiding();} public static void showEat(Person p){ p.eat(); } } abstract class Person { abstract void eat();publicString name;publicString sex;publicint age; } class Chinese extends Person {publicString name;publicString sex;publicint age;public Chinese(String name,String sex,int age){this.name=name;this.sex=sex;this.age=age;} void eat() { System.out.println("姓名："+name+"，性别："+sex+"，年龄："+age+"，我是中国人，我喜欢吃饭！"); }void shadowBoxing(){ System.out.println(name+"在练习太极拳！"); } } class English extends Person {publicString name;publicString sex;publicint age; public English(String name,String sex,int age){this.name=name;this.sex=sex;this.age=age;} void eat(){System.out.println("姓名："+name+"，性别："+sex+"，年龄："+age+"，我是英国人，我喜欢吃三明治！");} void horseRiding(){System.out.println(name+"在练习骑马！");} }

第3关：通关任务三
任务描述
本关任务：通过一个简单实例讲解并自己动手编写一个Java应用程序，全面复习Java面向对象知识。
相关知识
为了完成本关任务，我们通过一个实例来一步一步总结归纳Java面向对象的知识。

package test; interface A{} interface B{} class Animal{ public void move(){ System.out.println("动物可以移动"); } Animal(){ System.out.println("Animal()"); } Animal(int n){ System.out.println("Animal(int)"); } } final class Dog extends Animal implements A,B { final String name = "旺财"; final public void finalFun(){ } public void move(){ System.out.println("狗可以跳墙"); } public void move(int n){ System.out.println("这只狗可以跳"+n+"米的墙"); } public String toString() { return "I am a Dog " + super.toString(); } Dog(){ super(300); System.out.println("Dog()"); } Dog(int n){ System.out.println("Dog(int)"); } } class Test{ static void testsuper(){ System.out.println("-----testsuper----"); new Dog(); new Dog(1); } static void testoverride(){ System.out.println("-----testoverride-----"); Animal a = new Animal(); Animal b = new Dog(); a.move(); b.move(); } } public class JavaDemo{ public static void main(String[] args) { Test.testsuper(); Test.testoverride(); } } abstract class Employee{ public abstract double computePay(); } class Salary extends Employee{ public double computePay(){ return 0; } } interface C extends A,B{}

输出结果：
-----testsuper----
Animal(int)
Dog()
Animal()
Dog(int)
-----testoverride-----
Animal()
Animal(int)
Dog()
动物可以移动
狗可以跳墙
编程要求
教练和运动员案例：
乒乓球运动员和篮球运动员；
乒乓球教练和篮球教练；
跟乒乓球相关的人员都需要学习英语；
分析，这个案例中有哪些抽象类，哪些接口，哪些具体类。
分析过程如下：
在这里插入图片描述
具体输出要求请看测试说明。
测试说明
测试输入：
张继科
30
易建联
31
刘国梁
42
杜锋
37
预期输出：
张继科—30
人都是要睡觉的
乒乓球运动员吃大白菜，喝小米粥
乒乓球运动员学习如何发球和接球
乒乓球运动员说英语
易建联—31
人都是要睡觉的
篮球运动员吃牛肉，喝牛奶
篮球运动员学习如何运球和投篮
刘国梁—42
人都是要睡觉的
乒乓球教练吃小白菜，喝大米粥
乒乓球教练教如何发球和接球
乒乓球教练说英语
杜锋—37
人都是要睡觉的
篮球教练吃羊肉，喝羊奶
篮球教练教如何运球和投篮
开始你的任务吧，祝你成功！
参考代码：

package case3; import java.util.Scanner; public class Task3 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);String pppName = sc.next();int pppAge = sc.nextInt();String bpName = sc.next();int bpAge = sc.nextInt();String ppcName = sc.next();int ppcAge = sc.nextInt();String bcName = sc.next();int bcAge = sc.nextInt(); PingPangPlayer ppp=new PingPangPlayer(pppName,pppAge);System.out.println(pppName+"---"+pppAge);ppp.sleep();ppp.eat();ppp.study();ppp.speak();System.out.println("----------------"); BasketballPlayer bp=new BasketballPlayer(bpName,bpAge);System.out.println(bpName+"---"+bpAge);bp.sleep();bp.eat();bp.study();System.out.println("----------------"); PingPangCoach ppc=new PingPangCoach(ppcName,ppcAge);System.out.println(ppcName+"---"+ppcAge);ppc.sleep();ppc.eat();ppc.teach();ppc.speak();System.out.println("----------------"); BasketballCoach bc=new BasketballCoach(bcName,bcAge);System.out.println(bcName+"---"+bcAge);bc.sleep();bc.eat();bc.teach();System.out.println("----------------");} } interface SpeakEnglish { abstract void speak(); } abstract class Person { String name;int age;Person(String name,int age){this.name=name;this.age=age;}void sleep(){System.out.println("人都是要睡觉的");}abstract void eat(); } abstract class Player extends Person { Player(String name,int age){super(name,age);}abstract void study(); } abstract class Coach extends Person { Coach(String name,int age){super(name,age);}abstract void teach(); } class PingPangPlayer extends Player implements SpeakEnglish {PingPangPlayer(String name,int age){super(name,age);}void eat(){System.out.println("乒乓球运动员吃大白菜，喝小米粥");}void study(){System.out.println("乒乓球运动员学习如何发球和接球");}public void speak(){System.out.println("乒乓球运动员说英语");} } class BasketballPlayer extends Player { BasketballPlayer(String name,int age){super(name,age);}void eat(){System.out.println("篮球运动员吃牛肉，喝牛奶");}void study(){System.out.println("篮球运动员学习如何运球和投篮");} } class PingPangCoach extends Coach implements SpeakEnglish { PingPangCoach(String name,int age){super(name,age);}void eat(){System.out.println("乒乓球教练吃小白菜，喝大米粥");}void teach(){System.out.println("乒乓球教练教如何发球和接球");}public void speak(){System.out.println("乒乓球教练说英语");} } class BasketballCoach extends Coach { BasketballCoach(String name,int age){super(name,age);}void eat(){System.out.println("篮球教练吃羊肉，喝羊奶");}void teach(){System.out.println("篮球教练教如何运球和投篮");} }