文章目录
定义打印方法
题解：
方法：
多态性，是子类的对象赋给了父类的引用，使用的前提是有继承关系、有方法的重写
本题中的三个类都重写了toString()方法
那么很显然，需要找到一个类，是本题中三个类的共同父类，又有toString()方法
并且有forName()方法和newInstance()方法，以便在print()中能传入一个对象
不用想了，平时就是用 Object类，它是所有类的父类，又拥有各种各样的方法
找到该类以后，把这个类的对象作为参数传给print()，也就是“父类的引用”，
并且在方法体中应用上三个子类都重写了的方法来实现需求
这样，在Class.forName(className).newInstance()时，
就会帮助创建出“子类的对象”
从而实现“父类的引用指向子类的对象”，即多态性
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws Exception {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
String className = scanner.next();
// print就是需要你定义的方法
print(Class.forName(className).newInstance());
}
}
//write your code here......
//public static void print(Object obj){
//System.out.println(obj.getClass().getName());
//}
public static void print(Object obj){
System.out.println(obj.toString());
}
}
class First {
public String toString() {
return "First";
}
}
class Second {
public String toString() {
return "Second";
}
}
class Third {
public String toString() {
return "Third";
}
}类型判断
题解：
方法：这道题要求的是方法中返回实例的具体类型，传入的是一个实例，我们对这个实例调用getClass().getName()即可，直接返回，没什么好说的。
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws Exception {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
String className = scanner.next();
Base obj = (Base) Class.forName(className).newInstance();
System.out.println(getClassName(obj));
}
}
public static String getClassName(Base obj) {
//write your code here......
return obj.getClass().getName();
}
}
class Base {
}
class Sub1 extends Base {
}
class Sub2 extends Base {
}实现抽象方法
题解：
考验对方法的重写，然后调用父类的方法去实现题目的需求而已
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// Sub是需要你定义的子类
Base base = new Sub();
Scanner scanner = new Scanner(System.in);
while (scanner.hasNextInt()) {
int x = scanner.nextInt();
int y = scanner.nextInt();
base.setX(x);
base.setY(y);
System.out.println(base.calculate());
}
}
}
abstract class Base {
private int x;
private int y;
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
public int calculate() {
if (avg() == 0) {
return 0;
} else {
return sum() / avg();
}
}
/**
* 返回x和y的和
*/
public abstract int sum();
/**
* 返回x和y的平均值
*/
public abstract int avg();
}
class Sub extends Base {
//write your code here......
public int sum(){
return super.getX()+super.getY();
}
public int avg(){
return sum()/2;
}
}实现接口
题解：
主要考虑对ComparatorImpl实现类重写max方法，注意：接口是用来被实现（implements）的，实现接口的类称为实现类
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Comparator comparator = new ComparatorImpl();
Scanner scanner = new Scanner(System.in);
while (scanner.hasNextInt()) {
int x = scanner.nextInt();
int y = scanner.nextInt();
System.out.println(comparator.max(x, y));
}
}
}
interface Comparator {
/**
* 返回两个整数中的最大值
*/
int max(int x, int y);
}
class ComparatorImpl implements Comparator{
public int max(int x,int y){
return x>y?x:y;
}
}
