面向对象（抽象类、引用数据类型转换、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;
}

}