1、建立一个人类(Person)和学生类(Student),功能要求如下:
(1)Person中包括四种私有型的数据成员name、addr、sex、age,分别为字符串型,字符串型、字符串型及整形。表示姓名、地址、性别和年龄。一个四参构造方法,一个两参构造方法,一个无参构造方法,一个输出方法显示4中属性。
package com.lxh.eightchapter;
public class Person185 {
private String name;
private String addr;
private String sex;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddr() {
return addr;
}
public void setAddr(String addr) {
this.addr = addr;
}
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 Person185() {
}
public Person185(String name, String addr) {
this("李黑","陕西","男",20);
}
public Person185(String name, String addr, String sex, int age) {
this.name = name;
this.addr = addr;
this.sex = sex;
this.age = age;
}
@Override
public String toString() {
return "Person185 [name=" + name + ", addr=" + addr + ", sex=" + sex + ", age=" + age + "]";
}
}
(2)Student类继承Person类,并增加成员math、english存放数学和英语成绩。一个六参构造方法和一个两参构造方法,一个无参构造方法和输出六中属性。
package com.lxh.eightchapter;
public class Student185 extends Person185 {
private int math;
private int english;
public int getMath() {
return math;
}
public void setMath(int math) {
this.math = math;
}
public int getEnglish() {
return english;
}
public void setEnglish(int english) {
this.english = english;
}
public Student185() {
}
public Student185(String name,String addr) {
super(name,addr);
}
public Student185(String name,String addr,String sex,int age,int math,int english) {
super(name,addr);
this.math=math;
this.english=english;
}
@Override
public String toString() {
return "["+super.toString()+"math=" + math + ", english=" + english + "]";
}
}
package com.lxh.eightchapter;
public class Java185 {
public static void main(String[] args) {
Person185 per=new Person185("李黑","陕西");
System.out.println(per.toString());
Student185 stu=new Student185("张三","陕西","男",20,80,60);
System.out.println(stu.toString());
}
}
执行结果
Person185 [name=李黑, addr=陕西, sex=男, age=20]
[Person185 [name=李黑, addr=陕西, sex=男, age=20]math=80, english=60]
2、定义员工类,具有姓名、年龄、性别属性,并具有构造方法和显示数据方法。定义管理层类,继承员工类,并有自己的属性职务和年薪。定义职员类,继承员工类,并有自己的属性部门和月薪。
package com.lxh.eightchapter;
public class Staff {
private String name;
private int age;
private String sex;
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 getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Staff() {
}
public Staff(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
@Override
public String toString() {
return "Staff [name=" + name + ", age=" + age + ", sex=" + sex + "]";
}
}
package com.lxh.eightchapter;
public class Admin extends Staff {
private String duty;
private double salary;
public String getDuty() {
return duty;
}
public void setDuty(String duty) {
this.duty = duty;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public Admin() {
}
public Admin(String name, int age, String sex,String duty, double salary) {
super(name,age,sex);
this.duty = duty;
this.salary = salary;
}
@Override
public String toString() {
return "["+super.toString()+"duty=" + duty + ", salary=" + salary + "]";
}
}
package com.lxh.eightchapter;
public class Clerk extends Staff{
private String section;
private double mot;
public String getSection() {
return section;
}
public void setSection(String section) {
this.section = section;
}
public double getMot() {
return mot;
}
public void setMot(double mot) {
this.mot = mot;
}
public Clerk() {
}
public Clerk(String name, int age, String sex,String section, double mot) {
super(name,age,sex);
this.section = section;
this.mot = mot;
}
@Override
public String toString() {
return "["+super.toString()+"section=" + section + ", mot=" + mot + "]";
}
}
package com.lxh.eightchapter;
public class java2185 {
public static void main(String[] args) {
Admin pera=new Admin("李世",50,"男","经理",50000.20);
Clerk per=new Clerk("李雷",20,"男","人事部",500.2);
System.out.println(pera.toString());
System.out.println(per.toString());
}
}
执行结果
[Staff [name=李世, age=50, sex=男]duty=经理, salary=50000.2]
[Staff [name=李雷, age=20, sex=男]section=人事部, mot=500.2]
3、编写程序,统计出字符串want you to konw one thing中的字母n和o的个数?
public class java3185 {
public static void main(String[] args) {
String str="want you to know one thing";
char rest []=str.toCharArray();
int countn=0;
int counto=0;
for(int x=0;x
执行结果
n的个数为:4
0的个数为:4
4、建立一个可以实现整形数组的操作类(Array),类中允许操作的数组大小由外部动态指定,同时在Array类里需要提供有数组以下处理:进行数据的增加(如果数据满了则无法增加),可以实现数组的容量扩充,取得数组全部内容。完成之后再次基础上派生两个子类。
package com.lxh.eightchapter;
public class Array {
private int date[]; //整形数组
private int foot; //数组索引控制
public int[] getDate() {
return date;
}
public void setDate(int[] date) {
this.date = date;
}
public int getFoot() {
return foot;
}
public void setFoot(int foot) {
this.foot = foot;
}
public Array(int len) {
if(len>0) {
this.date=new int[len];//开辟空间
}else {
this.date=new int[1];//开辟一个空间
}
}
//实现数组容量扩充,给出的是扩充大小。实际大小:已有大小+扩充大小
public void increment(int num) {
int [] newdata=new int[this.date.length+num];
System.arraycopy(this.date, 0, newdata, 0, this.date.length);
this.date=newdata;//改变数组引用
}
public boolean add(int num) { //数据增加
if(this.foot
在这里插入代码片
package com.lxh.eightchapter;
public class SortArray extends Array {
public SortArray(int len) { //定义排序子类
super(len);
}
public int[] getDate() {
java.util.Arrays.sort(super.getDate());
return super.getDate();
}
}
package com.lxh.eightchapter;
public class DemoArray {
public static void main(String[] args) {
SortArray da=new SortArray (5);
System.out.println(da.add(5));
System.out.println(da.add(20));
System.out.println(da.add(52));
System.out.println(da.add(51));
System.out.println(da.add(22));
da.increment(3);
System.out.println(da.add(22));
System.out.println(da.add(2));
System.out.println(da.add(2));
int [] re=da.getDate();
for(int temp:re) {
System.out.println(temp+"、");
}
}
}
执行结果
2、
2、
5、
20、
22、
22、
51、
52、
package com.lxh.eightchapter;
public class RerverArray extends Array{ //定义反转子类
public RerverArray(int len) {
super(len);
}
public int[] getDate() {
int center=super.getDate().length/2;
int head=0;
int tail=super.getDate().length-1;
for(int x=0;x
package com.lxh.eightchapter;
public class DemoArray {
public static void main(String[] args) {
RerverArray da=new RerverArray (5);
System.out.println(da.add(5));
System.out.println(da.add(20));
System.out.println(da.add(52));
System.out.println(da.add(51));
System.out.println(da.add(22));
da.increment(3);
System.out.println(da.add(22));
System.out.println(da.add(2));
System.out.println(da.add(2));
int [] re=da.getDate();
for(int temp:re) {
System.out.println(temp+"、");
}
}
}
执行结果
2、
2、
22、
22、
51、
52、
20、
5、
1、 Java中通过 extends 关键字实现继承。
2、 Object 类是所有类的父类,该类中判断两个对象是否相等的方法是 public boolean equals(Object obj) ,取得对象完整信息的方法是 public String toString() 。
3、 当子类中定义的方法与父类方法同名且参数类型及个数、返回值类型相同时,称子类方法 覆写 父类方法,子类默认使用 本类已经覆写 方法,使用父类的同名方法,必须使用 super 关键字说明。
4、 当子类定义的成员变量与父类的成员变量同名时,称子类 覆盖 父类的成员变量,子类默认使用 本类 属性。使用父类的同名成员变量,必须用 super 关键字说明。
5、 如果子类定义了构造方法,在创建子类对象时首先默认调用 父类无参构造方法 ,然后再本类的构造方法。
6、 Java提供的三个内建的Annotation是: @Override 、 @Deprecated 、 @SuppressWarnings 。
1、 为类定义多个名称相同、但参数的类型或个数不同的方法的做法称为 A 。
A、 方法重载 B、 方法覆写 C、 方法继承 D、 方法重用
2、 现在有两个类A、B,以下描述中表示B继承自A的是 D 。
A、 class A extends B B、 class B implements A
C、 class A implements D、 class B extends A
3、 下面关于子类调用父类构造方法的描述正确的是 C 。
A、 子类定义了自己的构造方法,就不会调用父类的构造方法。
B、 子类必须通过super关键字调用父类有参的构造方法。
C、 如果子类的构造方法没有通过super调用父类的构造方法,那么子类会先调用父类中无参构造方法,之后再调用子类自己的构造方法。
D、 创建子类对象时,先调用子类自己的构造方法,让后再调用父类的构造方法。
4、 假设类X是类Y的父类,下列声明对象x的语句中不正确的是 D 。
A、 X x = new X() ; B、 X x = new Y() ;
C、 Y x = new Y() ; D、 Y x = new X() ;
5、 编译并运行下面的程序,结果 B 。
public class A {
public static void main(String args[]) {
B b = new B();
b.test();
}
void test() {
System.out.print(“A”);
}
}
class B extends A {
void test() {
super.test();
System.out.println(“B”);
}
}
A、 产生编译错误 B、 代码可以编译运行,并输出结果:AB
C、 代码可以编译运行,但没有输出 D、 编译没有错误,但会运行时会产生异常
6、 编译运行下面的程序,结果是 A 。
public class A {
public static void main(String args[]) {
B b = new B();
b.test();
}
public void test() {
System.out.print(“A”);
}
}
class B extends A {
void test() {
super.test();
System.out.println(“B”);
}
}
A、 产生编译错误,因为类B覆盖类A的方法test()时,降低了其访问控制的级别。
B、 代码可以编译运行,并输出结果:AB
C、 代码可以编译运行,但没有输出
D、 代码可以编译运行,并输出结果:A
7、 现在有两个类A、B,以下描述中表示B继承自A的是 D 。
A、 class A extends B B、 class B implements A
C、 class A implements D、 class B extends A
8、 下面 A 修饰符所定义的方法不能被子类所覆写。
A、 final B、 abstract D、 static D、 interface
1、 一个类不能即是子类又是父类。 ( √ )
2、 子类只能继承父类的成员,但不能修改父类成员。 ( × )
3、 Java语言只支持单继承,不支持多继承。 ( √ )
4、 子类可以继承父类的所有成员。 ( √ )
1、 举例说明子类对象的实例化过程。
答: 当通过关键字new实例化子类对象时,会默认调用父类的无参构造方法,为父类对象实例化,而后才会调用子类的构造方法,为子类对象实例化。
2、 简述this与super关键字的区别。
答: this和super都可以调用类中的属性、方法、构造方法,但是this调用的是本类操作,而super是由子类调用父类操作。
3、 简述方法的重载与覆写的区别。
答: 方法重载是发生在一个类之中,方法名称相同、参数的类型及个数不同,不受权限的限制。而覆写是发生在继承关系之中,子类定义了和父类定义了方法名称相同、参数类型及个数、返回值类型完全相同的方法时所发生的操作,在子类覆写父类方法时,被覆写的方法不能拥有比父类更严格的访问权限。
4、 在已有类的基础上派生新的类有什么好处?
答: 扩充已有类的功能,并且利用方法的覆写扩充已有方法的功能。
5、 如何区分子类和父类?子类可以继承父类的那些内容?
答: 子类使用extends继承父类,子类可以继承父类中的全部内容,但是对于私有操作属于隐式继承,而非私有操作属于显式继承。
6、 什么是多态?实现都态的方法有那些?
答: 多态性主要分为两个方面:
· 方法的多态性:重载与覆写
|- 重载:同一个方法名称,根据不同的参数类型及个数可以完成不同的功能;
|- 覆写:同一个方法,根据操作的子类不同,所完成的功能也不同。
· 对象的多态性:父子类对象的转换。
|- 向上转型:子类对象变为父类对象,格式:父类 父类对象 = 子类实例,自动;
|- 向下转型:父类对象变为子类对象,格式:子类 子类对象 = (子类) 父类实例,强制;
7、 简述JAVA SE中三个内建的Annotation的作用。
· @Override:准确的方法覆写;
· @Deprecated:某个结构(类、方法、属性)不再建议被用户所使用;
· @SuppressWarnings:压制编译时所产生的警告信息。