目录
Java面向对象 - 封装、继承和多态的综合练习
封装、继承和多态进阶(一)
封装、继承和多态进阶(二)
封装、继承和多态进阶(三)
Java面向对象 - 封装、继承和多态
什么是封装，如何使用封装
什么是继承，怎样使用继承
super关键字的使用
方法的重写与重载
抽象类
final关键字的理解与使用
接口
什么是多态，怎么使用多态
Java面向对象 - 类与对象
什么是类，如何创建类
构造方法
选择题(一) C CD
This关键字
类与对象练习
static关键字
选择题(二) D EG B
Java高级特性 - Java反射
了解 Class 对象
利用反射分析类的能力
在运行时使用反射分析对象
利用反射进行方法调用
Java面向对象 - 封装、继承和多态的综合练习
封装、继承和多态进阶(一)
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();
// 通过有参构造函数实例化Dog类对象dog
// dog调用talk()方法
// dog调用eat()方法
/********* begin *********/
Dog dog=new Dog (dogName,dogSex,dogColor);
dog.talk();
dog.eat();
/********* end *********/
// 通过有参构造函数实例化Cat类对象cat
// cat调用talk()方法
// cat调用eat()方法
/********* begin *********/
Cat cat=new Cat(catName,catSex,catWeight);
cat.talk();
cat.eat();
/********* end *********/
}
}
// 抽象类Pet 封装属性name和sex
// 构造函数初始化name和sex
// 声明抽象方法talk()
// 声明抽象方法eat()
abstract class Pet {
/********* begin *********/
public abstract void talk();
public abstract void eat();
private String name;
private String sex;
public String getname(){
return name;
}
public void setname(String name){
this.name=name;
}
public String getsex(){
return sex;
}
public void setsex(String sex){
this.sex=sex;
}
public Pet(String name,String sex){
this.name=name;
this.sex=sex;
}
/********* end *********/
}
// Dog类继承自Pet类 封装属性color
// 构造函数初始化name、sex和color
// 实现自己的talk()方法和eat()方法
// talk()输出'名称：name，性别：sex，颜色：color，汪汪叫'
// eat()输出'name吃骨头'
class Dog extends Pet {
/********* begin *********/
private String color;
public String getcolor(){
return color;
}
public void setcolor(String color){
this.color=color;
}
public Dog(String name,String sex,String color){
super(name,sex);
sex=super.getname();
name=super.getname();
this.color=color;
}
public void talk(){
System.out.println("名称："+super.getname()+"，性别："+super.getsex()+"，颜色："+color+"，汪汪叫");
}
public void eat(){
System.out.println(super.getname()+"吃骨头！");
}
/********* end *********/
}
// Cat类继承自Pet类 封装属性weight
// 构造函数初始化name、sex和weight
// 实现自己的talk()方法和eat()方法
// talk()输出'名称：name，性别：sex，体重：weight kg，喵喵叫'
// eat()输出'name吃鱼'
class Cat extends Pet {
/********* begin *********/
/********* begin *********/
private double weight;
public double getweight(){
return weight;
}
public void setweight(double weight){
this.weight=weight;
}
public Cat(String name,String sex,double weight){
super(name,sex);
sex=super.getname();
name=super.getname();
this.weight=weight;
}
public void talk(){
System.out.println("名称："+super.getname()+"，性别："+super.getsex()+"，体重："+weight+"kg，喵喵叫");
}
public void eat(){
System.out.println(super.getname()+"吃鱼！");
}
/********* end *********/
}
封装、继承和多态进阶(二)
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();
// 创建测试类对象test
// 创建Person类对象person1,引用指向中国人,通过有参构造函数实例化中国人类对象
// 通过showEat()方法调用Chinese的eat()方法
// 创建Person类对象person2,引用指向英国人,通过有参构造函数实例化英国人类对象
// 通过showEat()方法调用English的eat()方法
/********* begin *********/
Person person1=new Chinese(cName,cSex,cAge);
showEat (person1);
Person person2=new English(eName,eSex,eAge);
showEat (person2);
/********* end *********/
// 强制类型转换(向下转型) 调用Chinese类特有的方法shadowBoxing()
// 强制类型转换(向下转型) 调用English类特有的方法horseRiding()
/********* begin *********/
Chinese chinese=(Chinese) person1;
chinese.shadowBoxing();
English english=(English) person2;
english.horseRiding();
/********* end *********/
}
// 定义showEat方法，使用父类作为方法的形参，实现多态，传入的是哪个具体对象就调用哪个对象的eat()方法
/********* begin *********/
//题目中没有static 这里应该定义一个静态方法，如果不定义静态方法的话，上面showeat（对象）无法正常调用
public static void showEat(Person person){
person.eat();
}
/********* end *********/
}
// 抽象类Person 封装属性name、sex和age
// 构造函数初始化name、sex和age
// 声明抽象方法eat()
abstract class Person {
/********* begin *********/
private String name;
private String sex;
private int age;
public String getname(){
return name;
}
public void setname(String name){
this.name=name;
}
public String getsex(){
return sex;
}
public void setsex(String sex){
this.sex=sex;
}
public int getage(){
return age;
}
public void setage(int age){
this.age=age;
}
public Person (String name,String sex,int age){
this.name=name;
this.sex=sex;
this.age=age;
}
public abstract void eat();//定义抽象方法 让子类实现
/********* end *********/
}
// Chinese类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是中国人，我喜欢吃饭！'
// 定义子类特有方法shadowBoxing(),当父类引用指向子类对象时无法调用该方法 输出'name在练习太极拳！'
class Chinese extends Person {
/********* begin *********/
public Chinese(String name,String sex,int age){
super(name,sex,age);
sex=super.getname();
name=super.getname();
age=super.getage();
}
public void eat(){ //实现抽象方法eat() 编写方法体
System.out.println("姓名："+super.getname()+"，性别："+super.getsex()+"，年龄："+super.getage()+"，我是中国人，我喜欢吃饭！");
}
public void shadowBoxing(){
System.out.println(super.getname()+"在练习太极拳！");
}
/********* end *********/
}
// English类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是英国人，我喜欢吃三明治!'
// 定义子类特有方法horseRiding(),当父类引用指向子类对象时无法调用该方法 输出'name在练习骑马！'
class English extends Person {
/********* begin *********/
public English(String name,String sex,int age){
super(name,sex,age);
sex=super.getname();
name=super.getname();
age=super.getage();
}
public void eat(){ //实现抽象方法eat() 编写方法体
System.out.println("姓名："+super.getname()+"，性别："+super.getsex()+"，年龄："+super.getage()+"，我是英国人，我喜欢吃三明治！");
}
public void horseRiding(){
System.out.println(super.getname()+"在练习骑马！");
}
/********* end *********/
}
封装、继承和多态进阶(三)
package case3;
import java.util.Scanner;
public class Task3 {
public static void main(String[] args) {
@SuppressWarnings("resource")
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
// 输出'name---age'
// 分别调用sleep()、eat()、study()、speak()方法
/********* begin *********/
PingPangPlayer ppp=new PingPangPlayer(pppName,pppAge);
System.out.println(pppName+"---"+pppAge);
ppp.sleep();
ppp.eat();
ppp.study();
ppp.speak();
/********* end *********/
System.out.println("----------------");
// 篮球运动员
// 通过带参构造函数实例化BasketballPlayer对象bp
// 输出'name---age'
// 分别调用sleep()、eat()、study()方法
/********* begin *********/
BasketballPlayer bp=new BasketballPlayer(bpName,bpAge);
System.out.println(bpName+"---"+bpAge);
bp.sleep();
bp.eat();
bp.study();
/********* end *********/
System.out.println("----------------");
// 测试教练(乒乓球教练和篮球教练)
// 乒乓球教练
// 通过带参构造函数实例化PingPangCoach对象ppc
// 输出'name---age'
// 分别调用sleep()、eat()、teach()、speak()方法
/********* begin *********/
PingPangCoach ppc=new PingPangCoach(ppcName,ppcAge);
System.out.println(ppcName+"---"+ppcAge);
ppc.sleep();
ppc.eat();
ppc.teach();
ppc.speak();
/********* end *********/
System.out.println("----------------");
// 篮球教练
// 通过带参构造函数实例化BasketballCoach对象bc
// 输出'name---age'
// 分别调用sleep()、eat()、teach()方法
/********* begin *********/
BasketballCoach bc=new BasketballCoach(bcName,bcAge);
System.out.println(bcName+"---"+bcAge);
bc.sleep();
bc.eat();
bc.teach();
/********* end *********/
System.out.println("----------------");
}
}
// 说英语接口 声明抽象方法speak()
interface SpeakEnglish {
/********* begin *********/
void speak();
/********* end *********/
}
// 定义人的抽象类Person 封装name和age
// 无参构造函数
// 有参构造函数初始化name和age
// 定义具体方法sleep() 输出'人都是要睡觉的'
// 抽象方法eat()（吃的不一样）
abstract class Person {
/********* begin *********/
private String name;
private int age;
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;
}
public Person(String name,int age){
this.name=name;
this.age=age;
}
public void sleep(){
System.out.println("人都是要睡觉的");
}
abstract void eat();
/********* end *********/
}
// 定义运动员Player（抽象类）继承自Person类
// 无参构造函数
// 有参构造函数初始化name和age
// 运动员学习内容不一样，抽取为抽象 定义抽象方法study()
abstract class Player extends Person {
/********* begin *********/
public Player(String name,int age){
super(name,age);
name=super.getname();
age=super.getage();
}
abstract void study();
/********* end *********/
}
// 定义教练Coach（抽象类）继承自Person类
// 无参构造函数
// 有参构造函数初始化name和age
// 教练教的不一样 定义抽象方法teach()
abstract class Coach extends Person {
/********* begin *********/
public Coach(String name,int age){
super(name,age);
name=super.getname();
age=super.getage();
}
abstract void teach();
/********* end *********/
}
// 定义乒乓球运动员具体类PingPangPlayer 继承自Player类并实现SpeakEnglish类（兵乓球运动员需要说英语）
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'乒乓球运动员吃大白菜，喝小米粥'
// 实现自己的study()方法 输出'乒乓球运动员学习如何发球和接球'
// 实现自己的speak()方法 输出'乒乓球运动员说英语'
class PingPangPlayer extends Player implements SpeakEnglish {
/********* begin *********/
public PingPangPlayer(String name,int age){
super(name,age);
name=super.getname();
age=super.getage();
}
public void eat(){
System.out.println("乒乓球运动员吃大白菜，喝小米粥");
}
public void study(){
System.out.println("乒乓球运动员学习如何发球和接球");
}
public void speak(){
System.out.println("乒乓球运动员说英语");
}
/********* end *********/
}
// 定义篮球运动员具体类BasketballPlayer 继承自Player类 不需要继承接口，因为他不需要说英语
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'篮球运动员吃牛肉，喝牛奶'
// 实现自己的study()方法 输出'篮球运动员学习如何运球和投篮'
class BasketballPlayer extends Player {
/********* begin *********/
public BasketballPlayer(String name,int age){
super(name,age);
name=super.getname();
age=super.getage();
}
public void eat(){
System.out.println("篮球运动员吃牛肉，喝牛奶");
}
public void study(){
System.out.println("篮球运动员学习如何运球和投篮");
}
/********* end *********/
}
// 定义乒乓球教练具体类 PingPangCoach 继承自Coach类并实现SpeakEnglish类（兵乓球教练需要说英语）
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'乒乓球教练吃小白菜，喝大米粥'
// 实现自己的teach()方法 输出'乒乓球教练教如何发球和接球'
// 实现自己的speak()方法 输出'乒乓球教练说英语'
class PingPangCoach extends Coach implements SpeakEnglish {
/********* begin *********/
public PingPangCoach(String name,int age){
super(name,age);
name=super.getname();
age=super.getage();
}
public void eat(){
System.out.println("乒乓球教练吃小白菜，喝大米粥");
}
public void teach(){
System.out.println("乒乓球教练教如何发球和接球");
}
public void speak(){
System.out.println("乒乓球教练说英语");
}
/********* end *********/
}
// 定义篮球教练具体类BasketballCoach 继承自Coach类 不需要继承接口，因为他不需要说英语
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'篮球教练吃羊肉，喝羊奶'
// 实现自己的teach()方法 输出'篮球教练教如何运球和投篮'
class BasketballCoach extends Coach {
/********* begin *********/
public BasketballCoach(String name,int age){
super(name,age);
name=super.getname();
age=super.getage();
}
public void eat(){
System.out.println("篮球教练吃羊肉，喝羊奶");
}
public void teach(){
System.out.println("篮球教练教如何运球和投篮");
}
/********* end *********/
}
Java面向对象 - 封装、继承和多态
什么是封装，如何使用封装
package case1;
public class TestPersonDemo {
public static void main(String[] args) {
/********* begin *********/
// 声明并实例化一Person对象p
Person p = new Person();
// 给p中的属性赋值
p.setName("张三");
p.setAge(18);
// 调用Person类中的talk()方法
p.talk();
/********* end *********/
}
}
// 在这里定义Person类
class Person {
/********* begin *********/
private String name;
private int age;
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;
}
void talk() {
System.out.println("我是：" + name + "，今年：" + age + "岁");
}
/********* end *********/
}
什么是继承，怎样使用继承
package case2;
public class extendsTest {
public static void main(String args[]) {
// 实例化一个Cat对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
/********* begin *********/
Cat cat= new Cat();
cat.name="大花猫";
cat.age=6;
cat.voice();
cat.eat();
System.out.println(cat.name+cat.age+"岁");
/********* end *********/
// 实例化一个Dog对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
/********* begin *********/
Dog dog= new Dog();
dog.name="大黑狗";
dog.age=8;
dog.voice();
dog.eat();
System.out.println(dog.name+dog.age+"岁");
/********* end *********/
}
}
class Animal {
/********* begin *********/
protected String name;
protected int age;
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 ;
}
/********* end *********/
}
class Cat extends Animal {
// 定义Cat类的voice()和eat()方法
/********* begin *********/
public void voice(){
System.out.println(name+"喵喵叫");
}
public void eat(){
System.out.println(name+"吃鱼");
}
/********* end *********/
}
class Dog extends Animal {
// 定义Dog类的voice()和eat()方法
/********* begin *********/
public void voice(){
System.out.println(name+"汪汪叫");
}
public void eat(){
System.out.println(name+"吃骨头");
}
/********* end *********/
}
super关键字的使用
package case3;
public class superTest {
public static void main(String[] args) {
// 实例化一个Student类的对象s，为Student对象s中的school赋值，打印输出信息
/********* begin *********/
Person p= new Person();
p.setName("张三");
p.setAge(18);
p.talk();
Student stu= new Student();
stu.school="哈佛大学";
System.out.println("，学校："+stu.school);
/********* end *********/
}
}
class Person {
/********* begin *********/
private String name ;
private int age;
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;
}
public void talk(){
System.out.print("姓名："+name+"，年龄："+age);
}
/********* end *********/
}
class Student extends Person {
/********* begin *********/
public String school;
public String getSchool(){
return school;
}
public void setSchool(String name){
this.school= school;
}
/********* end *********/
}
方法的重写与重载
package case4;
public class overridingTest {
public static void main(String[] args) {
// 实例化子类对象s，调用talk()方法打印信息
/********* begin *********/
Student stu=new Student();
stu.talk("张三",18,"哈佛大学");
/********* end *********/
}
}
class Person {
/********* begin *********/
String name;
int age;
protected void talk(String name, int age){
this.name=name;
this.age=age;
System.out.print("我是："+this.name+"，今年："+this.age);
}
/********* end *********/
}
class Student extends Person {
/********* begin *********/
String school;
public void talk(String name,int age,String school){
super.talk("张三",18);
this.school=school;
System.out.println("岁，我在"+this.school+"上学");
}
/********* end *********/
}
抽象类
package case5;
public class abstractTest {
public static void main(String[] args) {
/********* begin *********/
// 分别实例化Student类与Worker类的对象，并调用各自构造方法初始化类属性。
Student stu=new Student("张三",20,"学生");
Worker wor=new Worker("李四",30,"工人");
// 分别调用各自类中被复写的talk()方法 打印信息。
stu.talk();
wor.talk();
/********* end *********/
}
}
// 声明一个名为Person的抽象类，在Person中声明了三个属性name age occupation和一个抽象方法——talk()。
abstract class Person {
/********* begin *********/
protected String name;
protected int age;
protected String occupation;
Person(String name,int age,String occupation){
this.name=name;
this.age=age;
this.occupation=occupation;
}
abstract void talk();
/********* end *********/
}
// Student类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class Student extends Person {
/********* begin *********/
Student(String name,int age,String occupation) {
super(name,age,occupation);
}
void talk(){
System.out.println("学生——>姓名："+name+"，年龄："+age+"，职业："+ occupation+"！");
}
/********* end *********/
}
// Worker类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class Worker extends Person {
/********* begin *********/
Worker(String name,int age,String occupation) {
super(name,age,occupation);
}
void talk(){
System.out.println("工人——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
}
/********* end *********/
}
final关键字的理解与使用
package case6;
public class finalTest {
public static void main(String args[]) {
Bike1 obj = new Bike1();
obj.run();
Honda honda = new Honda();
honda.run();
Yamaha yamaha = new Yamaha();
yamaha.run();
}
}
//不可以修改 final 变量的值
// final方法,不可以重写
class Bike1 {
int speedlimit = 90;
void run() {
speedlimit = 120;
System.out.println("speedlimit=120");
}
}
class Bike2 {
void run() {
System.out.println("running");
}
}
class Honda extends Bike2 {
void run() {
System.out.println("running safely with 100kmph");
}
}
class Bike3 {
}
class Yamaha extends Bike3 {
void run() {
System.out.println("running safely with 100kmph");
}
}
接口
package case7;
public class interfaceTest {
public static void main(String[] args) {
// 实例化一Student的对象s，并调用talk()方法，打印信息
/********* begin *********/
Student s =new Student();
s.talk();
/********* end *********/
}
}
// 声明一个Person接口，并在里面声明三个常量：name、age和occupation，并分别赋值，声明一抽象方法talk()
interface Person {
/********* begin *********/
String name="张三";
int age=18;
String occupation="学生";
abstract void talk();
/********* end *********/
}
// Student类继承自Person类 复写talk()方法返回姓名、年龄和职业信息
class Student implements Person {
/********* begin *********/
public void talk(){
System.out.println("学生——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
}
/********* end *********/
}
什么是多态，怎么使用多态
package case8;
public class TestPolymorphism {
public static void main(String[] args) {
// 以多态方式分别实例化子类对象并调用eat()方法
/********* begin *********/
show(new Dog());
show(new Cat());
show(new Lion());
}
public static void show(Animal a){
a.eat();
if(a instanceof Dog){
}else if(a instanceof Cat){
}else{
}
}
/********* end *********/
}
// Animal类中定义eat()方法
abstract class Animal {
/********* begin *********/
abstract void eat();
/********* end *********/
}
// Dog类继承Animal类 复写eat()方法
class Dog extends Animal {
/********* begin *********/
public void eat() {
System.out.println("eating bread...");
}
/********* end *********/
}
// Cat类继承Animal类 复写eat()方法
class Cat extends Animal {
/********* begin *********/
public void eat() {
System.out.println("eating rat...");
}
/********* end *********/
}
// Lion类继承Animal类 复写eat()方法
class Lion extends Animal {
/********* begin *********/
public void eat() {
System.out.println("eating meat...");
}
/********* end *********/
}
Java面向对象 - 类与对象
什么是类，如何创建类
package step1;
public class Test {
public static void main(String[] args) {
/********** Begin **********/
//创建Dog对象
//设置Dog对象的属性
//在main方法中创建一个名为wuhuarou的Dog对象，
//并设置name为五花肉，color为棕色，variety为阿拉斯加。
Dog wuhuarou = new Dog();
wuhuarou.name = "五花肉";
wuhuarou.color = "棕色";
wuhuarou.variety = "阿拉斯加";
//输出小狗的属性
System.out.println("名字：" +wuhuarou.name+ "，毛色：" +wuhuarou.color+ "，品种：" +wuhuarou.variety);
//调用方法
wuhuarou.eat();
wuhuarou.run();
/********** End **********/
}
}
//在这里定义Dog类
/********** Begin **********/
class Dog{
String name;
String color;
String variety;
void eat(){
System.out.println("啃骨头");
}
void run(){
System.out.println("叼着骨头跑");
}
}
构造方法
package step2;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String name = sc.next();
String sex = sc.next();
/********** Begin **********/
//分别使用两种构造器来创建Person对象
Person person1 = new Person();
Person person2 = new Person(name,sex);
/********** End **********/
}
}
//创建Person对象，并创建两种构造方法
/********** Begin **********/
class Person{
String name;
String sex;
public Person(){
System.out.println("一个人被创建了");
}
public Person(String name, String sex){
this.name = name;
this.sex = sex;
System.out.println("姓名："+name+'，'+"性别："+sex+'，'+"被创建了");
}
}
/********** End **********/
选择题(一) C CD
This关键字
package step3;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String name = sc.next();
int age = sc.nextInt();
String sex = sc.next();
Person p = new Person(name,age,sex);
p.display();
}
}
class Person{
String name = "张三";
int age = 18;
String sex = "男";
/********** Begin **********/
public Person(String name,int age,String sex){
this(age);
this.name = name;
this.sex = sex;
}
public Person(int age){
this.age = age;
}
public void display(){
String name = "baby";
int age = 45;
String sex = "女";
System.out.println("name：" + this.name);
System.out.println("age：" + this.age);
System.out.println("sex：" + this.sex);
}
/********** End **********/
}
类与对象练习
package step5;
public class Test {
/********** Begin **********/
static String name = "楚留香";
static
{
System.out.println("hello educoder");
}
public static void main(String[] args) {
System.out.println("我叫" + name);
study();
}
public static void study(){
System.out.println("我喜欢在educoder上学习java");
}
/********** End **********/
}
static关键字
package step5;
public class Test {
/********** Begin **********/
static String name = "楚留香";
static
{
System.out.println("hello educoder");
}
public static void main(String[] args) {
System.out.println("我叫" + name);
study();
}
public static void study(){
System.out.println("我喜欢在educoder上学习java");
}
/********** End **********/
}
选择题(二) D EG B
Java高级特性 - Java反射
了解 Class 对象
package step1;
/**
* 学员任务文件
*/
public class Reflect_stu {
public static void main(String[] args) {
System.out.println("通过Object 类中的 getClass() 获取的 Class 对象为：" + getPersonClass1());
System.out.println("通过静态方法 Class.forName() 获取的 Class 对象为：" + getPersonClass2());
System.out.println("通过类字面常量获取 Class 的对象为：" + getPersonClass3());
}
/**
* 通过 Object 类中的 getClass() 获取的 Class 对象
*
* @return
*/
public static Class getPersonClass1() {
/********** Begin *********/
Person person = new Person();
Class c = person.getClass();
return c;
/********** End *********/
}
/**
* 通过静态方法 Class.forName() 获取的 Class 对象
* <p>
* 注意：Person 类的全路径为: step1.Person
*
* @return
*/
public static Class getPersonClass2() {
/********** Begin *********/
Class c = null;
String classname = "step1.Person";
try{
c = Class.forName(classname); //一个类的完整路径加名称
}catch(ClassNotFoundException e){
}
return c;
/********** End *********/
}
/**
* 通过类字面常量获取 Class 的对象
*
* @return
*/
public static Class getPersonClass3() {
/********** Begin *********/
Class c = Person.class;
return c;
/********** End *********/
}
}
利用反射分析类的能力
package step2;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
class Apple {
private String name;
public Apple(){}
public Apple(String name){}
public void setName(String name) {
this.name = name;
}
}
public class Reflect_stu {
public static void main(String[] args) {
// 请根据提供的 classPath 获取 step2.Apple 的 Class 对象， 请使用 Class.forName() 方法， 注意捕获异常
// 通关之后，你也可以修改 clasapath 为其他类路径，分析某个类的能力， 例如: java.util.Date
String classPath = "step2.Apple";
Class clazz = null;
/********** Begin *********/
try{
clazz = Class.forName(classPath);
}catch(ClassNotFoundException e){
}
/********** End *********/
printFields(clazz);
printConstructors(clazz);
printMethods(clazz);
}
/**
* 请打印类的每个域,输出格式为：修饰符 类型 变量名;
* @param clazz
*/
public static void printFields(Class clazz) {
/********** Begin *********/
Field[] f = clazz.getDeclaredFields();
for(Field ff:f){
Class type = ff.getType();
int mod = ff.getModifiers();
System.out.print(Modifier.toString(mod)+" ");
System.out.print(type.getName()+" ");
System.out.println(ff.getName()+";");
}
/********** End *********/
}
/**
* 打印构造函数,输出格式为：修饰符 方法名称（参数）
* @param clazz
*/
public static void printConstructors(Class clazz) {
Constructor[] constructors = clazz.getDeclaredConstructors();
for (Constructor constructor : constructors) {
Class[] paramTypes = constructor.getParameterTypes();
/********** Begin *********/
String name = constructor.getName();
String modifiers = Modifier.toString(constructor.getModifiers());
if (modifiers.length() > 0) {
System.out.print(modifiers + " ");
}
System.out.print(name + "(");
/********** End *********/
printParamTypes(paramTypes);
}
}
/**
* 请针对每个方法打印其签名，格式为：修饰符 返回值类型 方法名称(参数);
* @param clazz
*/
public static void printMethods(Class clazz) {
Method[] methos = clazz.getDeclaredMethods();
for (Method method : methos) {
Class[] paramTypes = null;
/********** Begin *********/
String name = method.getName();
Class returnType = method.getReturnType();
String modifiers = Modifier.toString(method.getModifiers());
System.out.print(modifiers+" "+returnType.getName() + " " + name + "(");
paramTypes = method.getParameterTypes();
/********** End *********/
printParamTypes(paramTypes);
}
}
/**
* 打印方法参数
* @param paramTypes
*/
private static void printParamTypes(Class[] paramTypes) {
for (int j = 0; j < paramTypes.length; ++j) {
if (j > 0) {
System.out.print(",");
}
System.out.print(paramTypes[j].getName());
}
System.out.println(");");
}
}
在运行时使用反射分析对象
package step3;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
public class Reflect_stu {
public static String toString(Object obj) {
Class cl = obj.getClass();
String r = "";
r += "[";
// 请获取所有 Field 并设置访问权限为 true
/********** Begin *********/
Field[] fields = cl.getDeclaredFields();
AccessibleObject.setAccessible(fields, true);
/********** End *********/
for (Field f : fields) {
// 此处 if，逻辑为判断 Field 域是否为非静态域
if (!Modifier.isStatic(f.getModifiers())) {
if (!r.endsWith("[")) r += ",";
r += f.getName() + "=";
try {
// 请获取域的类型及值
/********** Begin *********/
Class t = f.getType();
Object val = f.get(obj);
/********** End *********/
// isPrimitive() 用于判断是否为基本数据类型，若为基础数据类型直接拼接，否则递归调用 toString 方法
if (t.isPrimitive()) r += val;
else r += toString(val);
} catch (Exception e) {
e.printStackTrace();
}
}
}
r += "]";
return r;
}
public static void main(String[] args) {
Person person = new Person(88, 19, 175);
System.out.println(toString(person));
}
}
class Person {
public Integer weight;
private Integer age;
private Double height;
public Person(Integer weight, Integer age, double height) {
this.weight = weight;
this.age = age;
this.height = height;
}
}
利用反射进行方法调用
package step4;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Reflect_stu {
public static void main(String[] args) throws InvocationTargetException {
//使用反射调用
Class clazz = null;
try {
clazz = Class.forName("step4.Apple");
/********** Begin *********/
Method setPriceMethod = clazz.getMethod("setPrice", double.class);
Constructor appleConstructor = clazz.getConstructor();
Object apple = appleConstructor.newInstance();
setPriceMethod.invoke(apple, 14);
Method getPriceMethod = clazz.getMethod("getPrice");
System.out.println(getPriceMethod.invoke(apple));
Method getTotal = clazz.getMethod("getTotal", double.class, int.class);
System.out.println(getTotal.invoke(apple, 20, 24));
/********** End *********/
} catch (Exception e) {
e.printStackTrace();
}
}
}
class Apple {
private double price;
private int count;
public Apple() {
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
public double getTotal(double price, int count) {
return price * count;
}
}本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
