//父类的指针可以指向子类的对象
//子类的对象可以贴上父类的标签
//只能调用指针类型中定义的方法
Truck bt2=new BigTruck("白色的");
bt2.transport();
Truck st2=new SmallTruck("黑色的");
st2.transport(); 1.例题： //定义一个卡车类,两个子类,大卡车,小卡车,卡车类中有个运货的方法,大小卡车分别重写该方法
//再定义一个货运站类,一个属性interval=50,在定义一个调度,根据一个货品重量,返回一个卡车
//货运站,发货的方法,接受一个货品重量,通过调度方法获取卡车,调用卡车的运货的方法
public class Easy {
public static void main(String[] args) {
Easy e=new Easy();
e.start();
}
public void start() {
for(int i=0;i<20;i++) {
double weight=Math.random()*80+20;
Truck t=getTruck(weight);
t.transport();
}
}
double interval=50;
public Truck getTruck(double weight) {
if(weight>=interval) {
return new BigTruck("随机色");
}else {
return new SmallTruck("随机色");
}
}
}
//卡车类
class Truck{
public Truck(String color2) {
//构造方法传入参数对属性初始化
this.color=color2;
}
public String color;
public void transport() {
System.out.println(this.color+"卡车在运货");
}
}
class BigTruck extends Truck{
public BigTruck(String colorr) {
super(colorr);
}
public void transport() {
System.out.println(color+"大卡车正在拉货");
}
public void lifting() {
System.out.println("货运货物");
}
}
class SmallTruck extends Truck{
public SmallTruck(String color) {
super(color);
}
public void transport() {
System.out.println(color+"小卡车正在拉货");
}
}
二、抽象类
//抽象类使用abstract修饰//抽象类用来被继承的
//抽象类可以继承实体类也可以继承抽象类
abstract class Animal{
public void eat() {
}
}
public abstract class Dragon extends Animal {
public void rain() {
System.out.println("排风布雨");
}
//抽象类中可以定义 抽象方法 但是没有实际，没有方法体
//继承抽象类的实体类必须实现抽象类中的抽象方法
//抽象方法不能用private修饰
public abstract void fly();
public static void main(String[] args) {
//new Dragon();
}
}
class FireDragon extends Dragon{
public void fly() {
}
}
class WaterDragon extends Dragon{
public void fly() {
}
}
class Station{
Dragon getDragon(int a) {
if(a%2==0) {
return new FireDragon();
}else {
return new WaterDragon();
}
}
public interface ICar {
//接口中的属性是常量
//接口中的量默认是常量 默认使用public static final来修饰
//常量名要全部大写
public static final int MAX=12;
//接口中所有的方法都是抽象方法
//在接口当中，定义抽象方法可以不写abstract
//接口中定义的方法都是用public abstract来修饰的
void run();
//接口中可以拥有default修饰的实体方法
//实例（对象）可以调用的方法
//访问权限是public
default void test() {}
}
interface ITest{
void test1();
}
//类通过implements实现接口
//实现接口的类必须实现接口中定义的方法 一个类可以实现多个接口
class Truck1 implements ICar,ITest{
int a=12;
@Override
public void run() {
}
@Override
public void test1() {
}
}
abstract class Truck2 implements ICar,ITest{
}
class Test extends Truck2{
public void run() {
}
public void test1() {
}
}
interface IEasy extends ICar,ITest{
} 四、关键字final //关键字final
//final修饰的类不可以被继承
//用final修饰的量不能重新赋值
//final修饰方法不可以被重写
//抽象类 抽象方法不能被final修饰
final String str;
final int[] arr= {1,2,3};
public Easy1(String code){
str=code;
//arr=new int[3];
arr[0]=22;
}
// void test() {
// str="张三";
// }
public static void main(String[] args) {
Easy1 e1=new Easy1("123");
System.out.println(e1.str);
Easy1 e2=new Easy1("234");
System.out.println(e2.str);
}
}
class A{
public final void test() {
}
}
class B extends A{
//public void test(){
//}
} 五、Static关键字 public class Easy4 {
//使用static来定义类的属性和方法
public static final int MAX=12;
public static int count=22;
public static void test() {
System.out.println("静态的方法");
//静态方法不能直接调用成员变量和方法
//demo();
Easy4 e4=new Easy4();
e4.demo();
}
public void demo() {
count=33;
test();
}
}
class AA{
public void a() {
//通过类名调用静态的方法和属性
Easy4.test();
System.out.println(ICar.MAX);
}
} 六、运行顺序 //每次在运行构造方法前会运行普通代码块
public class Demo {
public static void main(String[] args) {
new B();
new B();
}
}
class A{
static{
System.out.println("A========静态代码块");
}
{
System.out.println("A====代码块");
}
A(){
System.out.println("A=========");
}
}
class B extends A{
static{
System.out.println("B========静态代码块");
}
{
System.out.println("B====代码块");
}
B(){
System.out.println("B==========");
}
}
运行结果：
A========静态代码块
B========静态代码块
A====代码块
A=========
B====代码块
B==========
A====代码块
A=========
B====代码块
B==========
