面向对象（抽象类、引用数据类型转换、Object数组）

例一：女孩抽象父类

//abstract关键字修饰类的时候，表示这个类是抽象类

//抽象类不能产生对象，它只能充当父类！

//1、有抽象方法的类一定是抽象类;

//2、抽象类不一定有抽象方法

//3、抽象类除了类有abstract修饰符，它内部跟普通类一样，可以有：

// 属性、构造、已经实现的方法。

public abstract class Girl {

//abstract关键字表示抽象

//当它修饰方法的时候，表示类有这个方法，但是不能确定这个方法的实现，应该由它的子类去确定

public abstract void response();

}

子类继承父类

//子类在继承抽象类的时候，必须重写抽象类的抽象方法。

//否则这个子类也必须是抽象类。

public class Queen extends Girl{

@Override

public void response() {

// TODO Auto-generated method stub

}

}

子类继承

public class PureGirl extends Girl {

@Override

public void response() {

// TODO Auto-generated method stub

System.out.println(“嗯~你好坏~”);

}

}

男孩类有一个女孩类型的女朋友属性

public class Boy {

private Girl myGirl;

public Girl getMyGirl() {

return myGirl;

}

public void setMyGirl(Girl myGirl) {

this.myGirl = myGirl;

}

public void kiss(){

System.out.println(“让我亲一个嘛~~~”);

this.myGirl.response();

}

}

测试选择

import java.util.Scanner;

public class TestLove {

public static void main(String[] args) {

// TODO Auto-generated method stub

Boy boy = new Boy();

System.out.println(“请选择你喜欢的女孩类型：1、纯情；2、野蛮。”);

int choice = new Scanner(System.in).nextInt();

Girl girl = null;//产生一个Girl类型的变量名指向null

switch(choice){//根据选择产生不同的女孩对象

case 1:

girl = new PureGirl();break;//父类的引用指向子类的对象

case 2:

girl = new BoldGirl();break;

}

boy.setMyGirl(girl);

boy.kiss();

}

}

引用数据类型只有继承关系才能转换

父类

public class PetBean {

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 class DogBean extends PetBean {

private int boneNum;

public int getBoneNum() {

return boneNum;

}

public void setBoneNum(int boneNum) {

this.boneNum = boneNum;

}

}

测试

public class TestMain {

public static void main(String[] args) {

//1、基本数据类型的转型

//1-1、自动类型转换、隐式转换、从小范围的数据类型往大范围的数据类型转换

// 无风险\肯定成功

int a = ‘b’;

double f = 254;

//1-2、强制类型转换、显式转换、从大范围的数据往小范围的数据类型转换

// 有风险\丢失精度\无意义

a = (int)3.14;

char c = (char)12345670;

//2、引用数据类型的转换—只有有继承关系的类才能使用类型转换

//2-1、向上类型转换、自动类型转换、隐式类型转换、从小范围的数据类型往大范围的数据类型转换

// 无风险\肯定成功

PetBean p = new PetBean();//父类的引用可以指向子类的对象

//2-2、向下类型转换、强制类型转换、显式转换、从大范围的数据往小范围的数据类型转换

// 有风险/可能会抛出异常，终止程序的运行

//只有运行起来后，确实是本类引用指向本类对象或父类引用指向子类对象才可以成功

DogBean dog = (DogBean)p;

}

}

Object 数组（可变长度和装不同类型）

public class SuperArray {

//属性

public Object[] array;

private int index;//代表两层含义：1、下一个元素所在的下标；2、已经放了多少个元素。

public SuperArray(){
this.array = new Object[20];
}
//行为
//放入元素
public void add(Object num){
if(this.index >= this.array.length){
//扩容
Object[] newArray = new Object[this.array.length + 10];
System.arraycopy(this.array, 0, newArray, 0, this.array.length);
this.array = newArray;
}
//把传入的num放入到array当中去
this.array[index] = num;
this.index++;
}
//得到某个元素
public Object get(int index){
if(index < this.index && index >= 0){
return this.array[index];
}
throw new ArrayIndexOutOfBoundsException(index);//产生一个异常对象并且抛出
}
//修改某个元素
public void set(int index,Object newNum){
if(index < this.index && index >= 0){
this.array[index] = newNum;
}
throw new ArrayIndexOutOfBoundsException(index);
}
//删除某个位置的元素
public void remove(int index){
if(index < this.index && index >= 0){
System.arraycopy(this.array, index + 1, this.array, index , this.array.length - index - 1);
this.index -- ;
if(this.array.length - this.index >= 10 && this.array.length > 20){
Object[] newArray = new Object[this.array.length - 10];
System.arraycopy(this.array, 0, newArray, 0, newArray.length);
this.array = newArray;
}
}
throw new ArrayIndexOutOfBoundsException(index);
}
//获得元素的个数
public int size(){
return this.index;
}
public int getCapibility(){
return this.array.length;
}

}