1:final关键字(掌握)
(1)是最终的意思,可以修饰类,方法,变量。
(2)特点:
A:它修饰的类,不能被继承。
B:它修饰的方法,不能被重写。
C:它修饰的变量,是一个常量。
(3)面试相关:
A:局部变量
a:基本类型 值不能发生改变
b:引用类型 地址值不能发生改变,但是对象的内容是可以改变的
B:初始化时机
a:只能初始化一次。
b:常见的给值
定义的时候。(推荐)
构造方法中。
2:多态(掌握)
(1)同一个对象在不同时刻体现出来的不同状态。
(2)多态的前提:
A:有继承或者实现关系。
B:有方法重写。
C:有父类或者父接口引用指向子类对象。
多态的分类:
a:具体类多态
class Fu {}
class Zi extends Fu {}
Fu f = new Zi();
b:抽象类多态
abstract class Fu {}
class Zi extends Fu {}
Fu f = new Zi();
c:接口多态
interface Fu {}
class Zi implements Fu {}
Fu f = new Zi();
(3)多态中的成员访问特点
A:成员变量
编译看左边,运行看左边
B:构造方法
子类的构造都会默认访问父类构造
C:成员方法
编译看左边,运行看右边
D:静态方法
编译看左边,运行看左边
为什么?
因为成员方法有重写。
(4)多态的好处:
A:提高代码的维护性(继承体现)
B:提高代码的扩展性(多态体现)
(5)多态的弊端:
父不能使用子的特有功能。
现象:
子可以当作父使用,父不能当作子使用。
(6)多态中的转型
A:向上转型
从子到父
B:向下转型
从父到子
(7)孔子装爹的案例帮助大家理解多态
(8)多态的练习
A:猫狗案例
B:老师和学生案例
3:抽象类(掌握)
(1)把多个共性的东西提取到一个类中,这是继承的做法。
但是呢,这多个共性的东西,在有些时候,方法声明一样,但是方法体。
也就是说,方法声明一样,但是每个具体的对象在具体实现的时候内容不一样。
所以,我们在定义这些共性的方法的时候,就不能给出具体的方法体。
而一个没有具体的方法体的方法是抽象的方法。
在一个类中如果有抽象方法,该类必须定义为抽象类。
(2)抽象类的特点
A:抽象类和抽象方法必须用关键字abstract修饰
B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类
C:抽象类不能实例化
D:抽象类的子类
a:是一个抽象类。
b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。
(3)抽象类的成员特点:
A:成员变量
有变量,有常量
B:构造方法
有构造方法
C:成员方法
有抽象, 强制要求子类做的事情
有非抽象 子类继承的事情,提高代码的复用性
(4)抽象类的练习
A:猫狗案例练习
B:老师案例练习
C:学生案例练习
D:员工案例练习
(5)抽象类的几个小问题
A:抽象类有构造方法,不能实例化,那么构造方法有什么用?
用于子类访问父类数据的初始化
B:一个类如果没有抽象方法,却定义为了抽象类,有什么用?
为了不让创建对象
C:abstract不能和哪些关键字共存
a:final冲突
b:private 冲突
c:static 无意义
4:接口(掌握)
(1)回顾猫狗案例,它们仅仅提供一些基本功能。
比如:猫钻火圈,狗跳高等功能,不是动物本身就具备的,
是在后面的培养中训练出来的,这种额外的功能,java提供了接口表示。
(2)接口的特点:
A:接口用关键字interface修饰
interface 接口名 {}
B:类实现接口用implements修饰
class 类名 implements 接口名 {}
C:接口不能实例化
D:接口的实现类
a:是一个抽象类。
b:是一个具体类,这个类必须重写接口中的所有抽象方法。
(3)接口的成员特点:
A:成员变量
只能是常量
默认修饰符:public static final
B:构造方法
没有构造方法
C:成员方法
只能是抽象的
默认修饰符:public abstract
(4)类与类,类与接口,接口与接口
A:类与类
继承关系,只能单继承,可以多层继承
B:类与接口
实现关系,可以单实现,也可以多实现。
还可以在继承一个类的同时,实现多个接口
C:接口与接口
继承关系,可以单继承,也可以多继承
(5)抽象类和接口的区别(自己补齐)?
A:成员区别
抽象类:
接口:
B:关系区别:
类与类:
类与接口:
接口与接口:
C:设计理念不同
抽象类:is a,抽象类中定义的是共×××。
接口:like a,接口中定义的是扩展功能。
(6)练习:
A:猫狗案例,加入跳高功能
B:老师和学生案例,加入抽烟功能0
#####################################################################################
1:final关键字可以干什么?有什么特点?
最终的意思。可以修饰类,方法,变量。
它修饰类,类不能被继承
它修饰方法,方法不能被重写
它修饰变量,变量是常量
2:final关键字的面试题?
A:修饰局部变量
基本类型:值不能改变
引用类型:地址值不能改变
B:初始化时机
定义的时候
构造方法中
3:多态是什么,前提是什么?
同一个对象在不同时刻表现出来的不同的状态
A:有继承或者实现关系
B:有方法的重写
C:有父类或者父接口引用指向子类对象
4:多态中成员访问的特点?
成员变量
编译看左边,运行看左边
成员方法
编译看左边,运行看右边
静态方法
编译看左边,运行看左边
5:多态的好处及弊端?如何解决多态的弊端?
好处:
维护性和扩展性
弊端:父类不能使用子类特有功能
如何解决呢?
A:创建子类对象。(在内存中会多了一个对象)
B:向下转型
6:什么是向上转型?什么是向下转型?
子 - 父
父 - 子
多态的问题理解:
class 孔子爹 {
public int age = 40;
public void teach() {
System.out.println("讲解JavaSE");
}
}
class 孔子 extends 孔子爹 {
public int age = 20;
public void teach() {
System.out.println("讲解论语");
}
public void playGame() {
System.out.println("英雄联盟");
}
}
//Java培训特别火,很多人来请孔子爹去讲课,这一天孔子爹被请走了
//但是还有人来请,就剩孔子在家,价格还挺高。孔子一想,我是不是可以考虑去呢?
//然后就穿上爹的衣服,带上爹的眼睛,粘上爹的胡子。就开始装爹
//向上转型
孔子爹 k爹 = new 孔子();
//到人家那里去了
System.out.println(k爹.age); //40
k爹.teach(); //讲解论语
//k爹.playGame(); //这是儿子才能做的
//讲完了,下班回家了
//脱下爹的装备,换上自己的装备
//向下转型
孔子 k = (孔子) k爹;
System.out.println(k.age); //20
k.teach(); //讲解论语
k.playGame(); //英雄联盟
8:抽象类概述及其特点?
抽象类:继承的时候,提取了多个方法,而有些方法不是每个子类都是一模一样的实现,
这个时候,就应该把这样的方法不提供具体实现,而不提供具体实现的方法是一个抽象方法。
在一个类中,如果有抽象方法,该类必须定义为抽象类。
特点:
A:抽象类或者抽象方法由abstract修饰
B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类
C:抽象类不能实例化
D:抽象类的子类
a:是抽象类
b:是具体类,就要重写所有抽象方法
9:抽象类成员特点?
A:成员变量
有变量,有常量
B:构造方法
有。用于子类访问父类数据的初始化
C:成员方法
有抽象方法,有非抽象方法
10:抽象类练习?
11:抽象类的小问题
A:一个类如果没有抽象方法,可不可以定义为抽象类?如果可以,有什么意义?
B:abstract不能和哪些关键字共存
final
static
private
12:接口的概述及其特点?
接口:某个继承体系需要扩展功能的时候,就应该实现接口。
特点:
A:接口用interface修饰
B:类实现接口用implements修饰
C:接口不能实例化
D:接口的实现
a:抽象类
b:具体类,重写接口中的所有抽象方法
13:接口的成员特点?
A:成员变量 静态常量
B:成员方法 抽象的
14:抽象类和接口的区别?
A:成员区别
抽象类:
成员变量:可以变量,也可以常量
构造方法:有
成员方法:可以抽象,也可以非抽象
接口:
成员变量:只可以常量
成员方法:只可以抽象
B:关系区别
类与类
继承,单继承
类与接口
实现,单实现,多实现
接口与接口
继承,单继承,多继承
C:设计理念区别
"is a"
"like a"
抽象类 被继承体现的是:”is a”的关系。抽象类中定义的是该继承体系的共×××。
接口 被实现体现的是:”like a”的关系。接口中定义的是该继承体系的扩展功能。
15:接口的练习?
16:案例
猫狗案例,加入跳高的额外功能
老师和学生案例,加入抽烟的额外功能
教练和运动员案例(学生分析然后讲解)
抽象类练习:
//定义抽象类
abstract class Animal{
private String name;
private int age;
public Animal(){}
public Animal(String name,int age ){
this.name=name;
this.age=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 abstract void show();
}
class Dog extends Animal{
public Dog(){}
public Dog(String name,int age){
super(name,age);
}
public void show(){
System.out.println("小狗吃骨头");
}
}
class Cat extends Animal{
public Cat(){}
public Cat(String name,int age){
super(name,age);
}
public void show(){
System.out.println("小猫吃鱼");
}
}
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
Animal d=new Dog("旺财",3);
Animal c=new Cat("咪咪",2);
d.show();
System.out.println(d.getName()+"-----"+d.getAge());
c.show();
Animal d2=new Dog();
d2.setAge(4);
d2.setName("德福");
System.out.println(d2.getName()+"-----"+d2.getAge());
d2.show();
Animal c2=new Cat();
c2.setAge(3);
c2.setName("花花");
System.out.println(c2.getName()+"-----"+c2.getAge());
c2.show();
}
}
输出:
小狗吃骨头
旺财-----3
小猫吃鱼
德福-----4
小狗吃骨头
花花-----3
小猫吃鱼
Test2
//定义抽象类
abstract class Teacher{
private String name;
private int age;
public Teacher(){}
public Teacher(String name,int age){
this.name=name;
this.age=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 abstract void teach();
}
class LowTeacher extends Teacher{
public LowTeacher(){}
public LowTeacher(String name,int age){
super(name,age);
}
public void teach(){
System.out.println("教你看书");
}
}
class HighTeacher extends Teacher{
public HighTeacher(){}
public HighTeacher(String name,int age){
super(name,age);
}
public void teach(){
System.out.println("教你找书");
}
}
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
Teacher t=new LowTeacher("二狗子",35);
Teacher t2=new LowTeacher();
t2.setName("大壮");
t2.setAge(34);
System.out.println(t.getName()+"-----"+t.getAge());
t.teach();
System.out.println(t2.getName()+"-----"+t2.getAge());
t2.teach();
Teacher t3=new HighTeacher("小牛",29);
System.out.println(t3.getName()+"-----"+t3.getAge());
t3.teach();
}
}
输出:
二狗子-----35
教你看书
大壮-----34
教你看书
小牛-----29
教你找书
Test3
//定义抽象类
abstract class Student{
//私有变量,姓名,年龄,班级
private String name;
private int age;
private String grade;
//空构造函数
public Student(){}
//带参构造函数
public Student(String name,int age,String grade){
this.name=name;
this.age=age;
this.grade=grade;
}
// getter(),setter()
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 String getGrade(){
return grade;
}
public void setGrade(String grade){
this.grade=grade;
}
//两个抽象方法
public abstract void study();
public abstract void eat();
}
//子类继承父类
class Ystu extends Student{
public Ystu(){}
public Ystu(String name,int age,String grade){
//super关键字继承父类变量成员
super(name,age,grade);
}
//重写两个抽象方法
public void study(){
System.out.println("低档学生学123");
}
public void eat(){
System.out.println("低档学生吃炒饭");
}
}
class Ostu extends Student{
public Ostu(){}
public Ostu(String name,int age,String grade){
super(name,age,grade);
}
public void study(){
System.out.println("高档学生学ABC");
}
public void eat(){
System.out.println("高档学生吃白菜帮子");
}
}
public class Test {
public static void main(String[] args) {
Student s=new Ystu("小明",12,"六年级");
Student s2=new Ystu();
s2.setName("小红");
s2.setAge(11);
s2.setGrade("五年级");
System.out.println(s.getName()+"\t"+s.getAge()+"\t"+s.getGrade());
s.study();
s.eat();
System.out.println(s2.getName()+"\t"+s2.getAge()+"\t"+s2.getGrade());
s2.study();
s2.eat();
Student s3=new Ostu("大黄",19,"大一");
System.out.println(s3.getName()+"\t"+s3.getAge()+"\t"+s3.getGrade());
s3.study();
s3.eat();
}
}
输出:
小明 12 六年级
低档学生学123
低档学生吃炒饭
小红 11 五年级
低档学生学123
低档学生吃炒饭
大黄 19 大一
高档学生学ABC
高档学生吃白菜帮子
Test4
假如我们在开发一个系统时需要对员工类进行设计,员工包含3个属性:姓名、工号以及工资。
经理也是员工,除了含有员工的属性外,另为还有一个奖金属性。
请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问
//定义抽象类
abstract class Employee{
private String name;
private int number;
private int salary;
public Employee(){}
public Employee(String name,int number,int salary){
this.name=name;
this.number=number;
this.salary=salary;
}
/*public Employee(String name,int number,int salary,int bonus){
this.name=name;
this.number=number;
this.salary=salary;
this.bonus=bonus;
}*/
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
public int getNumber(){
return number;
}
public void setNumber(int number){
this.number=number;
}
public int getSalary(){
return salary;
}
public void setSalary(int salary){
this.salary=salary;
}
//抽象方法
public abstract void show();
}
//普通员工类
class Worker extends Employee{
public Worker(){}
public Worker(String name,int number,int salary){
super(name,number,salary);
}
public void show(){
System.out.println("我叫"+this.getName()+",工号是"+this.getNumber()+",工资是"+this.getSalary()+",我没有奖金");
}
}
//经理类
class Manager extends Employee{
//增加一个奖金的变量
private int bonus;
public Manager(){}
public Manager(String name,int number,int salary,int bonus){
super(name,number,salary);
this.bonus=bonus;
}
public int getBonus(){
return bonus;
}
public void setBonus(int bonus){
this.bonus=bonus;
}
public void show(){
System.out.println("我叫"+this.getName()+",工号是"+this.getNumber()+",工资是"+this.getSalary()+",我每个月奖金"+this.getBonus());
}
}
public class Test {
public static void main(String[] args) {
//员工类对象
Employee e=new Worker();
e.setName("屌丝");
e.setNumber(748);
e.setSalary(3500);
e.show();
//经理类对象
//由于bonus变量在子类中,只能用子类创建对象调用getBonus()方法
//或者将bonus变量放在父类中
Manager e2=new Manager();
e2.setName("Stephen");
e2.setNumber(13);
e2.setSalary(8000);
e2.setBonus(3000);
e2.show();
Manager m=new Manager("武大郎",19,5000,2000);
m.show();
}
}
输出:
我叫屌丝,工号是748,工资是3500,我没有奖金
我叫Stephen,工号是13,工资是8000,我每个月奖金3000
我叫武大郎,工号是19,工资是5000,我每个月奖金2000
接口练习:
猫狗加入跳高功能:
//跳高的接口
interface Jump{
//跳高方法
public abstract void jump();
}
//抽象类
abstract class Animal{
private String name;
private int age;
public Animal(){}
public Animal(String name,int age){
this.name=name;
this.age=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 abstract void eat();
//睡觉的普通方法
public void sleep(){
System.out.println("小动物该睡觉了");
}
}
//普通小猫类
class Cat extends Animal{
public Cat(){}
public Cat(String name,int age){
super(name,age);
}
public void eat(){
System.out.println("小猫吃鱼");
}
public void sleep(){
System.out.println("小猫该睡觉了");
}
}
//跳高小猫类,继承猫类和跳高接口
class CatJump extends Cat implements Jump{
public CatJump(){}
public CatJump(String name,int age){
super(name,age);
}
//重写接口抽象方法
public void jump(){
System.out.println("小猫会跳高了");
}
}
//普通小狗类
class Dog extends Animal{
public Dog(){}
public Dog(String name,int age){
super(name,age);
}
public void eat(){
System.out.println("小狗吃骨头");
}
public void sleep(){
System.out.println("小狗该睡觉了");
}
}
//跳高小狗类
class DogJump extends Dog implements Jump{
public DogJump(){}
public DogJump(String name,int age){
super(name,age);
}
public void jump(){
System.out.println("小狗会跳高了");
}
}
public class ZuoYe {
public static void main(String[] args) {
//定义跳高猫
CatJump cj=new CatJump();
cj.setName("咪咪");
cj.setAge(3);
System.out.println(cj.getName()+"\t"+cj.getAge());
cj.eat();
cj.sleep();
cj.jump();
System.out.println("+++++++++++++++++++++++");
DogJump dj=new DogJump("旺财",4);
System.out.println(dj.getName()+"\t"+dj.getAge());
dj.eat();
dj.sleep();
dj.jump();
}
}
输出:
咪咪 3
小猫吃鱼
小猫该睡觉了
小猫会跳高了
+++++++++++++++++++++++
旺财 4
小狗吃骨头
小狗该睡觉了
小狗会跳高了
老师学生案例,加入装逼功能
//定义装逼的接口
interface Zhuangbi{
public abstract void zhuangbi();
}
//定义抽象类
abstract class Person{
private String name;
private int age;
private String number;
public Person(){}
public Person(String name,int age,String number){
this.name=name;
this.age=age;
this.number=number;
}
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 String getNumber(){
return number;
}
public void setNumber(String number){
this.number=number;
}
//定义抽象方法
public abstract void work();
//定义普通方法
public void eat(){
System.out.println("吃饭");
}
}
//定义普通老师类
class Teacher extends Person{
public Teacher(){}
public Teacher(String name,int age,String number){
super(name,age,number);
}
public void work(){
System.out.println("老师教书");
}
public void eat(){
System.out.println("老师吃屎");
}
}
//定义装逼老师类
class TeacherZhuangbi extends Teacher implements Zhuangbi{
public TeacherZhuangbi(){}
public TeacherZhuangbi(String name,int age,String number){
super(name,age,number);
}
public void zhuangbi(){
System.out.println("老师学会装逼了!");
}
}
//定义普通学生类
class Student extends Person{
public Student(){}
public Student(String name,int age,String number){
super(name,age,number);
}
public void work(){
System.out.println("学生学习");
}
public void eat(){
System.out.println("学生吃×××毛啊");
}
}
//装逼学生类
class StudentZhuangbi extends Student implements Zhuangbi{
public StudentZhuangbi(){}
public StudentZhuangbi(String name ,int age,String number){
super(name,age,number);
}
public void zhuangbi(){
System.out.println("学生还学会装逼了?");
}
}
public class ZuoYe {
public static void main(String[] args) {
TeacherZhuangbi tz=new TeacherZhuangbi();
tz.setName("牛师傅");
tz.setAge(48);
tz.setNumber("009");
System.out.println(tz.getName()+"\t"+tz.getAge()+"\t"+tz.getNumber());
tz.work();
tz.eat();
tz.zhuangbi();
System.out.println("+++++++++++++++++++++++++");
StudentZhuangbi sz=new StudentZhuangbi("小瘪三",15,"213");
System.out.println(sz.getName()+"\t"+sz.getAge()+"\t"+sz.getNumber());
sz.work();
sz.eat();
sz.zhuangbi();
}
}
输出:
牛师傅 48 009
老师教书
老师吃屎
老师学会装逼了!
+++++++++++++++++++++++++
小瘪三 15 213
学生学习
学生吃×××毛啊
学生还学会装逼了?
/*
* 乒乓球运动员和篮球运动员
* 乒乓球教练和篮球教练
* 乒乓球相关的人都要学英语
* 此例将学英语和教设置为接口,运动员和教练分四个类
* 另一种将英语设置为接口,
* 人
* 运动员 教练
* 乒乓 篮球 乒乓 篮球
* */
//定义英语接口
interface English{
public abstract void english();
}
//定义教练接口
interface Teach{
public abstract void teach();
}
//定义抽象类 人
abstract class Person{
private String name;
private int age;
private String number;
public Person(){}
public Person(String name,int age,String number){
this.name=name;
this.age=age;
this.number=number;
}
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 String getNumber(){
return number;
}
public void setNumber(String number){
this.number=number;
}
public abstract void eat();
public void show(){
System.out.println("我是人");
}
}
//乒乓球运动员
class PingPangSporter extends Person implements English{
public PingPangSporter(){}
public PingPangSporter(String name,int age,String number){
super(name,age,number);
}
public void eat(){
System.out.println("乒乓球运动员吃胡萝卜");
}
public void show(){
System.out.println("我是乒乓球运动员");
}
public void english(){
System.out.println("我学会英语了");
}
}
//乒乓球教练 继承人类,实现双接口: 教 和英语
class PingPangTeacher extends Person implements Teach,English{
public PingPangTeacher(){}
public PingPangTeacher(String name,int age,String number){
super(name,age,number);
}
public void eat(){
System.out.println("乒乓球教练吃白菜帮子");
}
public void show(){
System.out.println("我是乒乓球教练张怡宁");
}
public void english(){
System.out.println("我学会英语了");
}
public void teach(){
System.out.println("我会教乒乓球了");
}
}
//篮球运动员
class BasketballSporter extends Person{
public BasketballSporter(){}
public BasketballSporter(String name,int age,String number){
super(name,age,number);
}
public void eat(){
System.out.println("篮球运动员吃榨菜");
}
public void show(){
System.out.println("我是篮球运动员");
}
}
//篮球教练 继承 人 类, 实现单接口: 教
class BasketballTeacher extends Person implements Teach{
public BasketballTeacher(){}
public BasketballTeacher(String name,int age,String number){
super(name,age,number);
}
public void eat(){
System.out.println("篮球教练吃窝头");
}
public void show(){
System.out.println("我是篮球教练史蒂芬森");
}
public void teach(){
System.out.println("我会教篮球了");
}
}
public class ZuoYe {
public static void main(String[] args) {
PingPangSporter ps=new PingPangSporter();
ps.setName("福原爱");
ps.setAge(25);
ps.setNumber("0102");
System.out.println(ps.getName()+"\t"+ps.getAge()+"\t"+ps.getNumber());
ps.eat();
ps.show();
ps.english();
System.out.println("+++++++++++++++++++++++++++");
PingPangTeacher pt=new PingPangTeacher();
pt.setName("张怡宁");
pt.setAge(29);
pt.setNumber("0106");
System.out.println(pt.getName()+"\t"+pt.getAge()+"\t"+pt.getNumber());
pt.eat();
pt.show();
pt.teach();
pt.english();
System.out.println("+++++++++++++++++++++++++++");
BasketballSporter bs=new BasketballSporter("脑残乔",29,"01004");
System.out.println(bs.getName()+"\t"+bs.getAge()+"\t"+bs.getNumber());
bs.eat();
bs.show();
System.out.println("+++++++++++++++++++++++++++");
BasketballTeacher bt=new BasketballTeacher("史蒂芬森",28,"01009");
System.out.println(bt.getName()+"\t"+bt.getAge()+"\t"+bt.getNumber());
bt.eat();
bt.show();
bt.teach();
}
}
输出:
福原爱 25 0102
乒乓球运动员吃胡萝卜
我是乒乓球运动员
我学会英语了
+++++++++++++++++++++++++++
张怡宁 29 0106
乒乓球教练吃白菜帮子
我是乒乓球教练张怡宁
我会教乒乓球了
我学会英语了
+++++++++++++++++++++++++++
脑残乔 29 01004
篮球运动员吃榨菜
我是篮球运动员
+++++++++++++++++++++++++++
史蒂芬森 28 01009
篮球教练吃窝头
我是篮球教练史蒂芬森
我会教篮球了
转载于:https://blog.51cto.com/yizhimayi/1752781