Java面向对象编程---＞抽象类、final、Object、多态

一、抽象类；

        1、写代码的过程中父类不需要被实例化，父类被实例化没有意义；

        2、Java中使用抽象类，限制实例化（abstract）;

        3、abstract也可用于方法，抽象方法；

        4、抽象方法没有方法体；

        5、抽象方法必须在抽象类里；

        6、抽象方法必须在子类中被实现，除非子类是抽象类；

        7、public abstract int calcRent(int days);

二、final；

        1、子类不想被其他类再继承的话使用final；

        2、方法不想被重写使用final；

        3、属性不希望再被修改使用final修饰常量；

        4、使用final修饰引用型变量，变量的值是固定不变的，而变量所指向的对象属性是可以变得

        5、常见错误：使用final修饰引用型变量，变量不可以再指向另外的对象

class Dog {
String name;
public Dog(String name) {
this.name = name;
    } 
}
class Test {
public static void main(String[] args) {
final Dog dog = new Dog("欧欧");
dog.name = "美美";
 dog = new Dog("亚亚");
    }
}

三、Object类；

        1、Object是所有类的父类；

        2、一个属性如果没有使用extends显性的继承另外一个类，那么这个类就继承于Object类

        3、Object类的主要方法to String 方法

public static void main(String [] args){
Person p=new Person();//创建Person的对象p;
System.out.println("不加toString()的输出:"+p);
System.out.println("加上toString()的输出:"+p.toString());
} 

        4、Object类的主要方法equals方法

public class TestPerson//声明类
{
public static void main(String [] args){
Person p1=new Person("王一",33,"220283...");//创建Person
的对象p1;
Person p2=new Person("王一",33,"220283....");//创建
Person的对象p2;
//调用父类Object的equals方法
System.out.println(p1.equals(p2)?"是同一个人":"不是同一个人");
}

        5、对象的比较：——==和equals()

                ==:比较两个基本数据类型变量的值是否相等

                     比较两个引用数据类型的值即内存地址是否相等，即是否指向同一对象；

                equals：两个对象的内容是否一致；

        6、自定义类需重写equals()，否则其对象比较结果总是false

        7、object类是所有Java类的根基类；

四、多态；

        1、同一种事物由于条件不同，产生的结果不同

        2、程序中的多态：同意一个引用类型，使用不同的实例而执行不同的操作；

        3、实现和使用多态①编写父类②编写子类，子类重写父类方法③运行时，使用父类类型

        4、实现多态的两种形式：①使用父类作为方法形参实现多态②使用父类作为方法返回值类型实现多态；

        5、多态示例代码：

package object;
public class TestPolym { class Animal {
int age=10;
public void shout(){
System.out.println("叫了一声！");
public static void main(String[] args) {
Animal animal = new Dog(); //向上可以自动转型
System.out.println(animal.age); //属性调用时，仍然是基类的属性 }
// animal.shout(); }
class Dog extends Animal {
int age=28;
animalCry(new Dog());
//传的具体是哪一个类就调用哪一个类的方法。大大提高了程序的可扩展性。
//如果没有多态，我们这里需要写很多重载的方法。如果增加一种动物，就需要 public void shout() {
System.out.println("旺旺旺！");
}
//有了多态，只需要增加这个类继承Animal基类就可以了。
animalCry(new Cat());
Dog dog = (Dog) animal; //编写程序时，如果想调用运行时类型的方法
dog.gnawBone();
System.out.println(dog instanceo
System.out.println(animal instanceof Cat);
System.out.println(animal instanceof Dog);
public void gnawBone(){
System.out.println(“我在啃骨头");
} } } class Cat extends Animal {
int age=18;
public void shout() {
System.out.println("喵喵喵喵！");
}
static void animalCry(Animal a){
a.shout();
} }

五、上机练习：

编写父类：

public abstract class MotoVehical {
    private String no;
    private String brand;
    public MotoVehical(){

    }
    public MotoVehical(String name,String brand){
        this.no = no;
        this.brand = brand;
    }
    public String getNo(){
        return no;
    }
    public void setNo(String no){
        this.no = no;
    }
    public String getBrand(){
        return brand;
    }
    public void setBrand(String brand){
        this.brand = brand;
    }
    public abstract int calcRent(int days);
}

编写子类Car

public class Car extends MotoVehical {
    private String type;
    public Car(){

    }
    public Car(String no,String brand,String type){
        super(no,brand);
        this.type = type;
    }
    public String getType(){
        return type;
    }
    public void setType(String type){
        this.type = type;
    }
    @Override
    public int calcRent(int days){
        if (this.type.equals("0")){
            return 600 * days;
        }else if(this.type.equals("1")){
            return 500 * days;
        }else if(this.type.equals("2")){
            return 300 * days;
        }else{
            System.out.println("您输入的车型腾讯互联租聘公司不存在！");
            return 0;
        }
    }
}

编写子类Bus

public class Bus extends MotoVehical {
    private int seatcount;
    public Bus(){

    }
    public Bus(String no,String brand,int seatcount){
        super(no,brand);
        this.seatcount = seatcount;
    }
    @Override
    public int calcRent(int days){
        if (this.seatcount > 16){
            return 1500 * days;
        }else{
            return 800 * days;
        }
    }
}

编写测试类

public class MotoVehicalTest {
    public static void main(String[] args) {
        Car car = new Car("豫Q 888888","别克","0");
        int totalOne = car.calcRent(5);
        System.out.println("租金为："+totalOne);
        Bus bus = new Bus("豫Q 666666","金杯",16);
        int totalTwo = bus.calcRent(5);
        System.out.println("租金为："+totalTwo);
        int total = totalOne + totalTwo;
        System.out.println("总租金是："+total);
    }
}

编写动物类

public abstract class Animal {
    private int age;
    public Animal(){

    }
    public Animal(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age = age;
    }
    public abstract String self(String Myself);
}

编写鱼类

public class Fish extends Animal{
    private int weight;
    public Fish(){

    }
    public Fish(int age,int weigth){
        super(age);
        this.weight = weigth;
    }
    public int getWeight(){
        return weight;
    }
    public void setWeight(int weight){
        this.weight = weight;
    }
    @Override
    public  String self(String Myself) {
        if (this.weight > 0) {
            return "我是一条鱼" + "我的体重是" + weight + "我最喜欢游泳!";
        }else{
            return "您的体重输入错误！";
        }
    }
}

编写鸟类

public class Birds extends Animal {
    private String color;
    public Birds(){

    }
    public Birds(int age,String color){
        super(age);
        this.color = color;
    }
    public String getColor(){
        return color;
    }
    public void setColor(String color){
        this.color = color;
    }
    @Override
    public String self(String Myself){
        if (this.color.equals("白色")){
            return "我是一只"+color+"的小鸟，我最喜欢飞！";
        }else if(this.color.equals("黑色")){
            return "我是一只"+color+"的小鸟，我最喜欢飞！";
        }else if(this.color.equals("黄色")){
            return "我是一只"+color+"的小鸟，我最喜欢飞！";
        }else if(this.color.equals("红色")){
            return "我是一只"+color+"的小鸟，我最喜欢飞！";
        }else if(this.color.equals("蓝色")){
            return "我是一只"+color+"的小鸟，我最喜欢飞！";
        }else{
            return "没有这种颜色的小鸟！";
        }
    }
}

编写测试类

public class AnimalTest {
    public static void main(String[] args) {
        Fish fish = new Fish(10,20);
        String f = fish.self("");
        System.out.println("小鱼的自我介绍是："+f);
        Birds birds = new Birds(12,"蓝色");
        String b = birds.self("");
        System.out.println("小鸟的自我介绍是："+b);
    }
}

编写父类

public abstract class Pet {
    int health;
    int love;
    public abstract void play();
}

编写狗类

public class Dog extends Pet{
    @Override
    public void play(){
        System.out.println("狗狗正在陪主人玩接飞盘游戏,健康值-10，亲密度+5");
    }
}

编写企鹅

public class Penguin extends Pet{
    @Override
    public void play(){
        System.out.println("企鹅正在陪主人玩游泳游戏，健康值-10，亲密度+5");
    }
}

编写主人类

public class Person {
    public void play(Pet pet){
        pet.play();
    }
    public Pet getPet(String typeId){
        if (typeId.equals("0")){
            return new Dog();
        }else{
            return new Penguin();
        }
    }

    public static void main(String[] args) {
        Person person = new Person();
        Pet dog = new Dog();
        person.play(dog);
        dog.play();
        Pet penguin = new Penguin();
        person.play(penguin);
        Pet pet = person.getPet("0");
        if(pet instanceof Dog){
            System.out.println("领养的是狗");
        }else if(pet instanceof Penguin){
            System.out.println("领养的是企鹅");
        }
    }
}