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");
}
}
1016
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
