Java基础第8天:Final关键字、static关键字、抽象类、接口
- 基础案例
- 训练案例1
- 训练描述:【final关键字特点】
- 训练案例1
- 需求说明:定义子父类,父类如果被final修饰,测试子类能否继承父类。
- 再定义普通的子父类,父类中有方法被final所修饰,测试子类能否重写该方法。
- 定义一个类,该类中有final修饰的变量,并对其进行初始化,在该类中定义一个普通方法,测试这个变量值能否修改。
-
- 操作步骤描述
-
- 创建Father类,该类被final修饰。
- 创建Son类,并继承Father类,查看编译结果。
- 将上述内容注释掉,接下来,定义普通的子父类关系。
- 在父类中定义被final所修饰的method方法,方法中打印内容为method father
- 子类中重写父类中method方法,打印内容为method son,查看编译结果。
- 在该子类中定义一个成员变量age,初始化值为10,对该成员变量用final所修饰。
- 在该子类中定义show方法,在方法中,将age值改为20,并打印age值。
public class Father { /*在父类中定义被final所修饰的method方法,方法中打印内容为method father*/ public void method(){ System.out.println("method father"); } } public class Son extends Father { @Override public void method(){ System.out.println("method son"); } } /* final: * 1. 创建Father类,该类被final修饰。 2. 创建Son类,并继承Father类,查看编译结果。 //不能继承 3. 将上述内容注释掉,接下来,定义普通的子父类关系。 4. 在父类中定义被final所修饰的method方法,方法中打印内容为method father 5. 子类中重写父类中method方法,打印内容为method son,查看编译结果。 //不能重写 6. 在该子类中定义一个成员变量age,初始化值为10,对该成员变量用final所修饰。 7. 在该子类中定义show方法,在方法中,将age值改为20,并打印age值。 //不能再赋值 */ public class test01 { }
- 训练案例2
- 训练描述:【static关键字特点】
- 训练案例2
- 需求说明:定义学生类,学生类有三个属性:name、age、graduateFrom(此属性用static修饰),该类中有成员show方法,方法中打印三个成员变量的值。
- 在测试类中创建该学生对象,为对象中的成员变量赋值,并调用show方法。
- 在测试类中再次创建学生对象,为对象中的成员变量赋值,并调用show方法。
- 发现问题,每次创建学生对象都需要给学生的毕业院校属性进行赋值,那么当学生的毕业院校都属于同一所学校时,这样每次创建对象都需要重新赋值很不方便,故而,将该属性graduateFrom新增static所修饰,让这个成员变量被所有对象所共享。
-
- 操作步骤描述
-
- 定义学生类,学生类有三个属性:name、age、graduateFrom,该类中有成员show方法,方法中打印三个成员变量的值
- 在测试类中创建该学生对象,为对象中的成员变量赋值,并调用show方法。
- 在测试类中再次创建学生对象,为对象中的成员变量赋值,并调用show方法。
- 发现问题,每次创建学生对象都需要给学生的毕业院校属性进行赋值,那么当学生的毕业院校都属于同一所学校时,这样每次创建对象都需要重新赋值很不方便,故而,将该属性graduateFrom新增static所修饰,让这个成员变量被所有对象所共享。
- 在测试类中创建两次学生对象,第一次创建学生对象时,给对象中的属性赋值,并调用show方法,第二次创建学生对象时,只给对象中的name、age属性赋值,调用show方法。
- 发现第二个学生对象调用show方法时,打印的学生信息中发现,该学生的毕业院校和第一个学生对象一致,从而证明被static所修饰的成员被该类的所有对象所共享。
- 在第一次创建学生对象时,给该学生的静态变量graduateFrom赋值时,发现有黄色警告,说明该成员如果被静态所修饰,应该用类名直接调用,故而在创建对象之前先用类名调用成员
-
/* 一、 需求说明:定义学生类,学生类有三个属性:name、age、graduateFrom(此属性用static修饰),该类中有成员show方法,方法中打印三个成员变量的值。 二、 在测试类中创建该学生对象,为对象中的成员变量赋值,并调用show方法。 三、 在测试类中再次创建学生对象,为对象中的成员变量赋值,并调用show方法。 四、 发现问题,每次创建学生对象都需要给学生的毕业院校属性进行赋值,那么当学生的毕业院校都属于同一所学校时,这样每次创建对象都需要重新赋值很不方便,故而,将该属性graduateFrom新增static所修饰,让这个成员变量被所有对象所共享。 */ public class Student { public String name; public int age; public static String graduateFrom ; public void show (){ System.out.println(name + age + graduateFrom); } } /* 一、 需求说明:定义学生类,学生类有三个属性:name、age、graduateFrom(此属性用static修饰),该类中有成员show方法,方法中打印三个成员变量的值。 二、 在测试类中创建该学生对象,为对象中的成员变量赋值,并调用show方法。 三、 在测试类中再次创建学生对象,为对象中的成员变量赋值,并调用show方法。 四、 发现问题,每次创建学生对象都需要给学生的毕业院校属性进行赋值,那么当学生的毕业院校都属于同一所学校时,这样每次创建对象都需要重新赋值很不方便,故而,将该属性graduateFrom新增static所修饰,让这个成员变量被所有对象所共享。 */ public class test02 { public static void main(String[] args) { Student student = new Student(); Student.graduateFrom="beida"; student.age=12; student.name="aaa"; student.show(); Student student2 = new Student(); student2.age=18; student2.name = "bbb"; student2.show(); } }
- 训练案例3
- 训练描述:【static方法的访问特点】
- 训练案例3
- 需求说明:定义学生类,类中有静态成员变量和非静态成员变量,有两个非静态成员方法show()、show2()和两个静态成员方法show3()、show4()
- 在学生类中演示静态方法能否访问静态成员及非静态成员,在非静态方法能否访问非静态成员及静态成员,并在静态中演示能否与this、super连用。
-
-
- 操作步骤描述
-
- 定义学生类,学生类有静态属性age,初始值为30。非静态属性name,初始值为林青霞
- 在该类中定义非静态方法show()、show2(),再定义静态方法show3()、show4()
- 在show2()方法与show4()方法中,方法体不需要写内容。
- 在非静态方法show()中打印name和age值,调用show2()、show4()方法,并用this调用成员变量为其赋值。
- 在静态方法show3()中打印name和age值,调用show2()、show4()方法,并用this调用成员变量为其赋值
-
/*1. 定义学生类,学生类有静态属性age,初始值为30。非静态属性name,初始值为林青霞 * 2. 在该类中定义非静态方法show()、show2(),再定义静态方法show3()、show4() 3. 在show2()方法与show4()方法中,方法体不需要写内容。 4. 在非静态方法show()中打印name和age值,调用show2()、show4()方法,并用this调用成员变量为其赋值。 5. 在静态方法show3()中打印name和age值,调用show2()、show4()方法,并用this调用成员变量为其赋值 * */ public class Student { public static int age = 30; public String name ="林青霞"; public void show(){ System.out.println(age + "--" + name); show2(); show4(); this.age=18; this.name="jack"; } public void show2(){ } public static void show3(){ //static方法只能调用static的变量,static的方法 System.out.println(age + "--");// + //name); //show2(); show4(); //this.age=18; //不能再赋值 //this.name="jack"; } public static void show4(){ } } /* static方法的访问特点 一、 需求说明:定义学生类,类中有静态成员变量和非静态成员变量,有两个非静态成员方法show()、show2()和两个静态成员方法show3()、show4() 二、 在学生类中演示静态方法能否访问静态成员及非静态成员,在非静态方法能否访问非静态成员及静态成员,并在静态中演示能否与this、super连用。 1. 定义学生类,学生类有静态属性age,初始值为30。非静态属性name,初始值为林青霞 2. 在该类中定义非静态方法show()、show2(),再定义静态方法show3()、show4() 3. 在show2()方法与show4()方法中,方法体不需要写内容。 4. 在非静态方法show()中打印name和age值,调用show2()、show4()方法,并用this调用成员变量为其赋值。 5. 在静态方法show3()中打印name和age值,调用show2()、show4()方法,并用this调用成员变量为其赋值 */ public class Test03 { }
- 训练案例4
- 训练描述:【抽象类】
- 训练案例4
- 需求说明:定义抽象类Animal,该类中有抽象方法和非抽象方法,分别演示其子类是抽象类与具体类的情况
-
-
- 操作步骤描述
-
- 定义抽象类Animal,其内有抽象方法eat(),与非抽象方法sleep(),该方法体内容为打印语句,打印“睡觉”。
- 定义Dog类,继承Animal类,不重写Animal类中任何方法
- 定义Cat类,继承Animal类,重写Animal类中eat方法,方法中打印“猫吃鱼”。
- 定义测试类AnimalDemo,在测试类中创建Animal对象。
- 在测试类中使用多态形式创建Cat对象,并调用eat方法与sleep方法。
/*1. 定义抽象类Animal,其内有抽象方法eat(),与非抽象方法sleep(),该方法体内容为打印语句,打印“睡觉”。*/
public abstract class Animal {
public abstract void eat();
public void sleep(){
System.out.println("sleep");
};
}
/*
抽象类
一、 需求说明:定义抽象类Animal,该类中有抽象方法和非抽象方法,分别演示其子类是抽象类与具体类的情况
1. 定义抽象类Animal,其内有抽象方法eat(),与非抽象方法sleep(),该方法体内容为打印语句,打印“睡觉”。
2. 定义Dog类,继承Animal类,不重写Animal类中任何方法
3. 定义Cat类,继承Animal类,重写Animal类中eat方法,方法中打印“猫吃鱼”。
4. 定义测试类AnimalDemo,在测试类中创建Animal对象。
5. 在测试类中使用多态形式创建Cat对象,并调用eat方法与sleep方法。
*/
public class AnimalDemo {
public static void main(String[] args) {
//Animal a = new Animal() ;
Animal a = new Cat() ;
a.eat();
a.sleep();
}
}
/*3. 定义Cat类,继承Animal类,重写Animal类中eat方法,方法中打印“猫吃鱼”*/
public class Cat extends Animal {
@Override
public void eat(){
System.out.println("猫吃鱼");
};
}
/*2. 定义Dog类,继承Animal类,不重写Animal类中任何方法*/
public abstract class Dog extends Animal{
}
-
- 训练案例5
- 训练描述:【抽象类】
- 训练案例5
- 需求说明:抽象类的老师案例,具体事物:基础班老师,就业班老师;具体事物:基础班老师,就业班老师
-
- 操作步骤描述
-
- 基础班老师:成员变量:name、age,构造方法:无参、有参,成员方法:getXxx()、setXxx()、teach(){}。
- 就业班老师:成员变量:name、age,构造方法:无参、有参,成员方法:getXxx()、setXxx()、teach(){}。
- 抽象类老师:成员变量:name、age,构造方法:无参、有参,成员方法:getXxx()、setXxx()、teach()。
-
public class BasicTeacher extends Teacher { @Override public void teacher(){ System.out.println(age + "--"+ name +"basic"); } } public abstract class Teacher { public String name; public 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 void teacher(){}; } /*抽象类 一、 需求说明:抽象类的老师案例,具体事物:基础班老师,就业班老师;具体事物:基础班老师,就业班老师 5.2. 操作步骤描述 1. 基础班老师:成员变量:name、age,构造方法:无参、有参,成员方法:getXxx()、setXxx()、teach(){}。 2. 就业班老师:成员变量:name、age,构造方法:无参、有参,成员方法:getXxx()、setXxx()、teach(){}。 3. 抽象类老师:成员变量:name、age,构造方法:无参、有参,成员方法:getXxx()、setXxx()、teach()。 */ public class Test05 { public static void main(String[] args) { Teacher t1 = new BasicTeacher() ; Teacher t2 = new WorkTeahcer(); t1.age= 18; t1.name = "aaa"; t1.teacher(); t2.age= 28; t2.name = "bbb"; t2.teacher(); } } public class WorkTeahcer extends Teacher{ @Override public void teacher(){ System.out.println(age + "--"+ name +"work"); } }
- 训练案例6
- 训练描述:【接口】
- 训练案例6
- 需求说明:让所有的猫具备跳高的额外功能
-
- 操作步骤描述
-
- 定义跳高接口Jumpping,该接口中有一个抽象跳高方法jump()。
- 定义抽象类Animal,该类中有属性姓名name、年龄age,还有一个抽象吃饭eat()方法。
- 定义猫类Cat,该类继承Animal,并实现跳高接口,重写抽象类中eat()方法与接口中的跳高jump()方法。
- 定义测试类InterfaceTest,在测试类中,创建猫对象,给对象成员变量赋值,最后调用猫的吃饭和跳高方法。
/*该类中有属性姓名name、年龄age,还有一个抽象吃饭eat()方法。*/
public 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 class Cat extends Animal implements Jumpping {
public Cat() {}
public Cat(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println( "猫吃鱼");
}
@Override
public void jump() {
System.out.println("猫跳高");
}
}
public interface Jumpping {
public abstract void jump();
}
/*
1. 定义跳高接口Jumpping,该接口中有一个抽象跳高方法jump()。
2. 定义抽象类Animal,该类中有属性姓名name、年龄age,还有一个抽象吃饭eat()方法。
3. 定义猫类Cat,该类继承Animal,并实现跳高接口,重写抽象类中eat()方法与接口中的跳高jump()方法。
4. 定义测试类InterfaceTest,在测试类中,创建猫对象,给对象成员变量赋值,最后调用猫的吃饭和跳高方法。
*/
public class Test06 {
public static void main(String[] args) {
Cat cat = new Cat();
cat.setAge(18);
cat.setName("aaa");
System.out.println(cat.getAge() + cat.getName());
cat.eat();
cat.jump();
}
}
- 扩展案例
- 训练案例1
- 训练描述:
- 训练案例1
- 分析以下需求,并用代码实现:
1.定义项目经理类
属性:
姓名 工号 工资 奖金
行为:
工作work
2.定义程序员类
属性:
姓名 工号 工资
行为:
工作work
要求:向上抽取一个父类,让这两个类都继承这个父类,共有的属性写在父类中,子类重写父类中的方法
编写测试类:完成这两个类的测试
-
-
- 操作步骤描述
-
- 定义抽象雇员类Employee,该类中有属性:姓名name,工号id,工资salary,抽象方法:工作work()。
- 定义项目经理类Manager,该类继承雇员类,重写父类中抽象方法work(){}。
- 定义程序员类Programmer,该类继承雇员类,重写父类中抽象方法work(){}。
- 定义测试类Test,创建项目经理对象与程序员对象,为对象属性进行初始化,并调用工作方法。
-
/*1. 定义抽象雇员类Employee,该类中有属性:姓名name,工号id,工资salary,抽象方法:工作work()。*/ public abstract class Employee { public String name; public int id; public double salary; public abstract void work(); public Employee(String name, int id, double salary) { this.name = name; this.id = id; this.salary = salary; } } public class Manager extends Employee { public double jianjing; public Manager(String name, int id, double salary, double jianjing) { super(name, id, salary); this.jianjing = jianjing; } @Override public void work() { System.out.println("工作workmmm"); } } public class Programmer extends Employee { public Programmer(String name, int id, double salary) { super(name, id, salary); } @Override public void work() { System.out.println("工作workppp"); } } public class Test07 { public static void main(String[] args) { Manager m = new Manager("mm",18,500,500); m.work(); Programmer p = new Programmer("pp",20,5000); p.work(); } }
- 训练案例2
- 训练描述:
- 训练案例2
分析以下需求,并用代码实现
1.定义手机类
行为:
打电话,发短信
2.定义接口IPlay
行为:
玩游戏
3.定义旧手机类继承手机类
行为:
继承父类的行为
4.定义新手机继承手机类实现IPlay接口
行为:继承父类的行为,重写玩游戏方法
5.定义测试类
在测试类中定义一个 用手机的方法,要求该方法既能接收老手机对象,也能接收新手机对象
在该方法内部调用打电话,发短信以及新手机特有的玩游戏方法
public interface IPlay {
public void play();
}
public class NewPhone extends Phone implements IPlay {
@Override
public void call() {
super.call();
}
@Override
public void send() {
super.send();
}
@Override
public void play() {
System.out.println("play");
}
}
public class OldPhone extends Phone{
@Override
public void call() {
super.call();
}
@Override
public void send() {
super.send();
}
}
/* 1.定义手机类 抽象
行为:
打电话,发短信
*/
public abstract class Phone {
public void call(){
System.out.println("call");
};
public void send(){
System.out.println("send");
};
}
/*
分析以下需求,并用代码实现
1.定义手机类 抽象
行为:
打电话,发短信
2.定义接口IPlay 接口
行为:
玩游戏
3.定义旧手机类继承手机类
行为:
继承父类的行为
4.定义新手机继承手机类实现IPlay接口
行为:继承父类的行为,重写玩游戏方法
5.定义测试类
在测试类中定义一个 用手机的方法,要求该方法既能接收老手机对象,也能接收新手机对象
在该方法内部调用打电话,发短信以及新手机特有的玩游戏方法
*/
public class Test08 {
public static void main(String[] args) {
OldPhone old = new OldPhone();
old.call();
old.send();
NewPhone phone2 = new NewPhone();
phone2.call();
phone2.send();
phone2.play();
}
}
-
-
- 操作步骤描述
-
略
-
- 训练案例3
- 训练描述:
- 训练案例3
分析以下需求,并用代码实现:
1.定义动物类:
行为:
吼叫;没有具体的吼叫行为
吃饭:没有具体的吃饭行为
2.定义缉毒接口
行为:
缉毒
3.定义缉毒狗:犬的一种
行为:
吼叫:汪汪叫
吃饭:狗啃骨头
缉毒:用鼻子侦测毒
4.定义测试类:
使用多态的形式创建缉毒狗对象,调用缉毒方法和吼叫方法
/*1.定义动物类:abstract
行为:
吼叫;没有具体的吼叫行为
吃饭:没有具体的吃饭行为*/
public abstract class Animal {
public abstract void vocie();
public abstract void eat();
}
public class Dog extends Animal {
@Override
public void vocie() {
System.out.println("wanwan");
}
@Override
public void eat() {
System.out.println("gutou");
}
}
public interface Du {
public abstract void du();
}
public class DuDog extends Dog implements Du {
@Override
public void vocie() {
super.vocie();
}
@Override
public void eat() {
super.eat();
}
@Override
public void du() {
System.out.println("duudud");
}
}
public class test09 {
public static void main(String[] args) {
DuDog d = new DuDog();
d.du();
d.eat();
d.vocie();
}
}
-
-
- 操作步骤描述
-
略
-
- 训练案例4
- 训练描述:
- 训练案例4
分析以下需求,并用代码实现:
1.定义动物类
属性:
年龄,颜色
行为:
eat(String something)方法(无具体行为,不同动物吃的方式和东西不一样,something表示吃的东西)
生成空参有参构造,set和get方法
2.定义狗类继承动物类
行为:
eat(String something)方法,看家lookHome方法(无参数)
3.定义猫类继承动物类
行为:eat(String something)方法,逮老鼠catchMouse方法(无参数)
4.定义Person类
属性:
姓名,年龄
行为:
keepPet(Dog dog,String something)方法
功能:喂养宠物狗,something表示喂养的东西
行为:
keepPet(Cat cat,String something)方法
功能:喂养宠物猫,something表示喂养的东西
生成空参有参构造,set和get方法
5.定义测试类(完成以下打印效果):
keepPet(Dog dog,String somethind)方法打印内容如下:
年龄为30岁的老王养了一只黑颜色的2岁的宠物
2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃
keepPet(Cat cat,String somethind)方法打印内容如下:
年龄为25岁的老李养了一只灰颜色的3岁的宠物
3岁的灰颜色的猫眯着眼睛侧着头吃鱼
-
-
- 操作步骤描述
-
略
public abstract class Animal {
private String color;
private int age;
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Animal() {
}
public Animal(String color, int age) {
this.color = color;
this.age = age;
}
public void eat(String something){};
}
public class Cat extends Animal {
public Cat(String color, int age) {
super(color, age);
}
@Override
public void eat(String something) {
super.eat(something);
System.out.println("maochi" + something);
}
public void catchMouse(){
System.out.println("zhua lao shu");
}
}
public class Dog extends Animal {
public Dog(String color, int age) {
super(color, age);
}
@Override
public void eat(String something) {
super.eat(something);
System.out.println("gouchi" + something);
}
public void lookHome(){
System.out.println("lookhome");
}
}
public class Person {
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 Person() {
}
public void keepPet(String name, int age,Dog dog, String something){
System.out.println("年龄为" + age + "的" + name + "养了一只" + dog.getColor() + dog.getAge() + "的宠物");
//年龄为30岁的老王养了一只黑颜色的2岁的宠物
//2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃
System.out.println(dog.getAge() + dog.getColor() +"gougou"+"两只前腿死死的抱住"+something + "猛吃");
}
public void keepPet(String name, int age,Cat cat,String something){
System.out.println("年龄为" + age + "的" + name + "养了一只" + cat.getColor() + cat.getAge() + "的宠物");
//年龄为30岁的老王养了一只黑颜色的2岁的宠物
//2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃
System.out.println(cat.getAge() + cat.getColor() +"猫眯着眼睛侧着头"+ "猛吃" + something );
}
}
public class test10 {
public static void main(String[] args) {
Person p1 = new Person();
Dog dog = new Dog("HEI",2);
p1.keepPet("老王",30,dog,"骨头");
Person p2 = new Person();
Cat cat = new Cat("Hui",3);
p2.keepPet("老li",25,cat,"yu");
}
}