- 第十章十一章作业
- 1.读代码
- 2.使用静态变量和静态方法时实现产品的唯一序列号编号
- 3.抽象类的使用：继承含含有抽象方法的抽象类的子类必须实现抽象类
- 4.匿名内部类的使用
- 5.局部内部类
- 6.综合应用
- 7.外部其他类访问成员内部类
- 8.枚举的使用switch
创建子类对象时在类的调用顺序
- 1.父类的静态代码块和静态属性初始化：优先级一样，按先后顺序调用
- 2.子类的静态代码块和静态属性初始化：优先级一样，按先后顺序调用
- 3.父类的普通代码块和普通属性初始化：优先级一样，按先后顺序调用
- 4.父类的构造方法
- 5.子类的普通代码块和普通属性初始化：优先级一样，按先后顺序调用
- 6.子类的构造方法
package com.chapter10_11;
/**
* @author whj
* @version 1.0
*/
public class Homework02 {
public static void main(String[] args) {
System.out.println( Frock.getCurrentNum());
System.out.println( Frock.getCurrentNum());
Frock frock01 = new Frock();
System.out.println(frock01.getSerialNumber());
Frock frock02 = new Frock();
System.out.println(frock02.getSerialNumber());
Frock frock03 = new Frock();
System.out.println(frock03.getSerialNumber());
}
}
class Frock{
private static int currentNum = 100000;//衣服序列号起始值
private int serialNumber;//当前序列号
public Frock() {
this.serialNumber = getCurrentNum();
}
public static int getCurrentNum(){//获得序列号
return currentNum += 100;
}
public int getSerialNumber() {
return serialNumber;
}
}
package com.chapter10_11;
/**
* @author whj
* @version 1.0
*/
public class Homework03 {
public static void main(String[] args) {
Animal cat = new Cat();
cat.shout();
Animal dog = new Dog();
dog.shout();
}
}
abstract class Animal{
abstract void shout();
}
class Cat extends Animal{
@Override
void shout() {
System.out.println("猫会喵喵叫");
}
}
class Dog extends Animal {
@Override
void shout() {
System.out.println("狗会汪汪叫。");
}
}
语法：new interface/class（){};//相当于直接创建了类的对象，该类实现了接口功能，或是对类继承，重写方法。
package com.chapter10_11;
/**
* @author whj
* @version 1.0
*/
public class Homework04 {
public static void main(String[] args) {
Cellphone cellphone = new Cellphone();
cellphone.testWork(new IA() {//匿名内部类
@Override
public void work() {
System.out.println("功能是计算。");
}
});
}
}
interface IA{
void work();//接口的计算功能
}
class Cellphone {
public void testWork(IA ia){
ia.work();//计算功能
}
}
要求创建了外部类才能创建内部类
package com.chapter10_11;
/**
* @author whj
* @version 1.0
*/
public class Homework05 {
public static void main(String[] args) {
A a = new A();//先创建外部类
A.B b = a.new B();//再创建内部类
b.show();
}
}
class A {
private final String name = "zh";
class B {
private final String name = "whj";
public void show(){
System.out.println(A.this.name + name);
}
}
}
-
不同的交通工具实现接口功能
-
工厂可以得到不同的工具
-
人有名字和交通工具两种属性，通过调用不同的方法获得不同的工具，实现不同的功能。
public class Homework06 {
public static void main(String[] args) {
Person tang = new Person("唐僧", Factory.getHorse());
tang.common();
tang.passRiver();
tang.passMountain();
}
}
//人
class Person {
private String name;
private Vehicles vehicles;
public Person(String name, Vehicles vehicles) {
this.name = name;
this.vehicles = vehicles;
}
public void common(){
//普通情况使用马
if (!(vehicles instanceof Horse)){
vehicles = Factory.getHorse();
}
vehicles.work();
}
public void passRiver(){
if (!(vehicles instanceof Boat)){
vehicles = Factory.getBoat();
}
vehicles.work();
}
public void passMountain(){
if (!(vehicles instanceof Plane)){
vehicles = Factory.getPlane();
}
vehicles.work();
}
}
//工厂
class Factory {//工厂,返回交通工具
//马只有一个。使用饿汉式创建马的实例对象
private static Horse horse = new Horse();//内部创建对象
private Factory() {//构造器私有化
}
public static Horse getHorse(){//返回一个可以获取内部对象的
return horse;
}
public static Boat getBoat(){//但是船每次都不同
return new Boat();
}
public static Plane getPlane(){//飞机都不同
return new Plane();
}
}
//各个交通工具
class Plane implements Vehicles {
@Override
public void work() {
System.out.println("过火焰山时，使用飞机。。。");
}
}
class Horse implements Vehicles {
@Override
public void work() {
System.out.println("一般情况，使用马儿。。。");
}
}
class Boat implements Vehicles{
@Override
public void work() {
System.out.println("过河时,使用小船。。。");
}
}
//接口
interface Vehicles {
void work();
}
-
1.直接创建一个新的对象
-
2.内部类所处的外部类暴露一个获取内部类的方法。
package com.chapter10_11; /** * @author whj * @version 1.0 */ public class Homework07 { public static void main(String[] args) { Car car = new Car(42.5); Car.Air air = car.new Air();//air 对象时固定的 air.flow(); System.out.println(air); car.setTemperature(-13); car.getAir().flow(); System.out.println(car.getAir()); car.setTemperature(13); air.flow(); System.out.println(air); } } class Car { private double temperature; class Air { public void flow() { if (temperature > 40.0) { System.out.println("空调吹冷风。"); } else if (temperature < 0.0) { System.out.println("空调吹暖风。"); } else { System.out.println("空调关闭。"); } } } public Car(double temperature) { this.temperature = temperature; } public double getTemperature() { return temperature; } public void setTemperature(double temperature) { this.temperature = temperature; } public Air getAir() {//每次都是创建新对象 return new Air(); } }
switch（）中，写入枚举对象，
在每个case之后，直接写上在枚举类中，当以的枚举对象即可。
package com.chapter10_11;
/**
* @author whj
* @version 1.0
*/
public class Homework08 {
public static void main(String[] args) {
Color color = Color.BLACK;
color.show();
switch (color) {
case RED:
System.out.println();
case BLUE:
System.out.println();
default:
System.out.println();
}
}
}
package com.chapter10_11;
/**
* @author whj
* @version 1.0
*/
public enum Color implements ShowColor{
RED(255,0,0),BLUE(0,0,255),
BLACK(0,0,0),YELLOW(255,255,0),
GREEN(0,255,0);
private int redValue;
private int greenValue;
private int blueValue;
private Color(int redValue, int greenValue, int blueValue) {
this.redValue = redValue;
this.greenValue = greenValue;
this.blueValue = blueValue;
}
public int getRedValue() {
return redValue;
}
public int getGreenValue() {
return greenValue;
}
public int getBlueValue() {
return blueValue;
}
@Override
public String toString() {
return "Color{" +
"redValue=" + redValue +
", greenValue=" + greenValue +
", blueValue=" + blueValue +
'}';
}
@Override
public void show() {
System.out.println("redValue=" + redValue +
", greenValue=" + greenValue +
", blueValue=" + blueValue );
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）