1.实验目的
1）进一步熟悉Java语法特征
2）初步掌握Java面向对象特征
3）了解包的使用
4）Java编程实现简单功能
2.实验内容
1）下面的程序有错误请修改并编译运行。
写两个java文件，分别定义如下类A，B，改正错误,编译运行。
package my.abc;
class A {
public int x;
public void print() { //自主填上执行内容}
}
package my.xyz;
import abc.A;
class B {
public static void main(String[]args) {
A a = new A();
a.x = 100;
a.print();
}
}}
2）定义一个表示学生的类student,包括的成员变量有学号、姓名、性别、年龄，包括的成员方法有获得学号、姓名、性别、年龄和修改年龄。书写Java程序创建student类的对象及测试其方法。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
3）扩充修改2的程序，为student类定义构造方法初始化所有的成员，增加一个方法public String printInfo()，该方法将student类对象的所有成员信息组合形成一个字符串并输出，在主类中创建student类的对象及测试其方法。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
4）阅读下面的程序
import java.io.*;
class A
{
void callme()
{
System.out.println("调用A的callme()的方法”）
}
}
class B extends A
{
void callme()
{
System.out.println("调用B的callme()的方法”）
}
}
public class Ex
{
public static void main(String args[])
{
A a=new B();
a.callme();
}
}
A a=new B();a.callme();a调用的是A的方法还是B的方法呢？为什么？编译运行验证之。
5）抽象并定义一个动物类(Animal)（抽象类），它包含动物的基本属性，例如名称(name)、年龄(age)、重量（weight）等，并设计相应的动作（用 抽象方法,如abstract void GetArea(); 或空方法，void GetArea(){}），例如跑(run)、跳(jump)、走(walk) 、吃（eat）等。再定义一个猫（Cat）类和一个狗类（Dog），继承动物类(Animal)，改写父类eat方法和run方法。再定义一个白猫(whileCat)，继承猫类，改写父类的eat方法。（方法体里只需用输出语句输出相应信息即可,编写主类测试这些定？编译运行验证之。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
6）编写java程序，求13的13次方的最后三位数。（研究乘法的规律发现：乘积的最后三位的值只与乘数和被乘数的后三位有关，与乘数和被乘数的高位无关。）
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
3.实验分析、代码及运行结果
1）
package my.abc;
public class A {
public int x;
public void print() {System.out.println(x);}
}
package my.xyz;
import my.abc.A;
class B {
public static void main(String[] args) {
A a = new A();
a.x = 100;
a.print();
}
}
运行结果：
分析: A类在my.abc包下,导入时import my.abc.A即可;A类和B类未在一个包下,
默认访问权限为default,需要加public修饰符
2）
package cn.whb.work2;
public class student {
private long id;
private String name;
private boolean gender;
private int age;
public static void main(String[] args) {
student st = new student(1001,"张三",true,18);
System.out.println(st.getGender());
st.setGender("女");
System.out.println(st.getGender());
}
student(){
}
// 构造方法
student(long id,String name,boolean gender,int age){
this.id = id;
this.name = name;
this.gender = gender;
this.age = age;
}
// 获得学号
public long getId() {
return id;
}
// 设置学号
public void setId(long id) {
this.id = id;
}
// 获得姓名
public String getName() {
return name;
}
// 设置姓名
public void setName(long id) {
this.name = name;
}
// 获得性别
public String getGender() {
return gender==true? "男":"女";
}
// 设置性别
public void setGender(String gen) {
gender = gen.equals("男")?true:false;
}
// 获得年龄
public int getAge() {
return age;
}
// 设置年龄
public void setAge(int age) {
this.age = age;
}
}
运行结果:
分析:
将属性封装为private私有属性,对各个属性设置相应的get方法和set方法,重载构造方法(默认构造方法会被覆盖,需要手写一个)
3）
package cn.whb.work2;
public class student {
private long id;
private String name;
private boolean gender;
private int age;
public static void main(String[] args) {
student st = new student(1001,"张三",true,18);
System.out.println(st.printInfo());
}
student(){
}
// 构造方法
student(long id,String name,boolean gender,int age){
this.id = id;
this.name = name;
this.gender = gender;
this.age = age;
}
public String printInfo() {
String gen = gender==true? "男":"女";
return "学号:"+id+" 姓名:"+name+" 性别:"+gen+" 年龄:"+age;
}
// 获得学号
public long getId() {
return id;
}
// 设置学号
public void setId(long id) {
this.id = id;
}
// 获得姓名
public String getName() {
return name;
}
// 设置姓名
public void setName(long id) {
this.name = name;
}
// 获得性别
public String getGender() {
return gender==true? "男":"女";
}
// 设置性别
public void setGender(String gen) {
gender = gen.equals("男")?true:false;
}
// 获得年龄
public int getAge() {
return age;
}
// 设置年龄
public void setAge(int age) {
this.age = age;
}
}
运行结果:
分析: 将各属性与字符串连接,自动转换为字符串,然后返回
4）
import java.io.*;
class A
{
void callme()
{
System.out.println("调用A的callme()的方法");
}
}
class B extends A
{
void callme()
{
System.out.println("调用B的callme()的方法");
}
}
public class Ex
{
public static void main(String args[])
{
A a=new B();
a.callme();
}
}
A a=new B();a.callme();a调用的是A的方法还是B的方法呢？为什么？编译运行验证之。
运行结果:
分析: 由多态的性质可知(向上转型),a调用的是B中的方法
5）
package cn.whb.work2;
abstract public class Animal {
String name;
int age;
int weight;
abstract void run();
abstract void jump();
abstract void walk();
abstract void eat();
}
class Cat extends Animal{
@Override
void run() {
System.out.println("猫轻轻的跑了..");
}
@Override
void jump() {
}
@Override
void walk() {
}
@Override
void eat() {
System.out.println("嗷呜...");
}
}
class Dog extends Animal{
@Override
void run() {
System.out.println("狗飞快的跑了");
}
@Override
void jump() {
}
@Override
void walk() {
}
@Override
void eat() {
System.out.println("狗,舔.......");
}
}
class whileCat extends Cat{
void eat() {
System.out.println("白猫吃.....");
}
}
class Test{
public static void main(String[] args) {
Cat cat1 = new Cat();
cat1.eat();
cat1.run();
Dog d1 = new Dog();
d1.eat();
d1.run();
whileCat wcat = new whileCat();
wcat.eat();
wcat.run();
}
}
运行结果:
分析:
子类必须实现抽象父类的所有方法，如果子类也是抽象类,则不用实现
6）
解法一(暴力):
-----------------------------------
public class Test {
public static void main(String[] args) {
long a = (long) Math.pow(13, 13);
String aa = "" + a;
System.out.println(aa);
System.out.println(aa.substring(aa.length()-3));
}
}
----------------------------------
解法二(合理利用题意):
---------------------------------
public class Test {
public static void main(String[] args) {
int a = 13;
String aa;
for(int i=0;i<12;i++) {
a *= 13;
aa = "" + a;
while(aa.length()<3){
aa = "0" + aa;
}
a = Integer.parseInt(aa.substring(aa.length()-3));
}
System.out.println(a);
}
}
运行结果：
总结：
继承:
子类的对象也是父类的对象,但反过来不成立.
java中子类必须调用父类的构造函数.如果没有用super()明确指明的话,默认调用没有参数的那个构造函数,
如果自己定义了一个构造函数将
默认的无参构造函数覆盖掉,并且没有再定义无参构造函数,则会报错.
```可以通过super(参数)的形式在子类的构造函数中调用父类的有参数构造函数,此时,如果父类没有
无参数 构造函数也不会报错.
extends关键字用来表明父类:
class Person{}
class Student extends Person{}
Student拥有Person类的属性和方法.
多态:
子类通过重写父类的方法,可以用自身的行为替换父类的行为.方法的重写是实现多态的必要条件.
多态指的是同一个方法调用,由于对象不同可能会有不同的行为.
多态的要点：
1. 多态是方法的多态,不是属性的多态(多态与属性无关).
2. 多态的存在要有3个必要条件：继承,方法重写,父类引用指向子类对象.
3. 父类引用指向子类对象后,用该父类引用调用子类重写的方法,此时多态就出现了.
对于子类和父类对象的相互转化,向上自动专型,向下需要强制类型转换.
向下指的是从父类==>子类.
抽象类:
抽象方法:
使用abstract修饰的方法,没有方法体,只有声明.定义的是一种“规范”,就是告诉子类必须要给抽象方法
提供具体的实现.
抽象类:
包含抽象方法的类就是抽象类.通过abstract方法定义规范,然后要求子类必须定义具体实现.通过抽象类,
我们就可以做到严格限制子类的设计,使子类之间更加通用.