JAVA的子类继承-重载-多态的使用-抽象类-接口的实例化

JAVA的继承关系

总之一句话就是父亲有的子类都可以直接用，但是子类有的父类不能直接调用，这就是继承

import java.util.Scanner;
class Vehicle{
    void  start(){
        System.out.println("start！");
    }
}
class Car extends Vehicle{
    @Override
    void start() {
        super.start();
    }
}
public class Main {


    public static void main(String[] args) {
        Car c = new Car();
        c.start();

    }
}

//方法的重载就是类名和方法名其实是一样的

import java.util.Scanner;
//方法的重载
class Vehicle{
    int seats;
    Vehicle(){   //输出1
        seats = 4;
        System.out.println(seats);
    }
    Vehicle(int seats){ //重载的构造方法  
        System.out.println(seats);
    }
   void setSeats(){  //没有参数的方法  输出3
        seats=6;
       System.out.println(seats);
    }
    void setSeats(int seats){  //有参数的方法
        this.seats=seats;
        System.out.println(seats);
    }
}
public class Main {
    public static void main(String[] args) {
       Vehicle Car = new Vehicle(); //开辟类的空间
        Vehicle Bus = new Vehicle(5);
        Car.setSeats();
        Car.setSeats(7);

    }
}

多态的实例：我感觉吧就是引入了一个第三方，通过第三方去调用你所定义的类，不是在main中直接去调用而是使用第三方去调用，文中的我感觉就是那个Person就是起到的这个效果

import java.util.Scanner;
//多态性的使用,
//其实我感觉就是引用了第三方，这样可以少一点代码，通过第三方来进行输出
class Vehicle{
    void  start(){
        System.out.println("start！");
    }
}
class Car extends Vehicle{
    @Override
    void start() {
        System.out.println("小车以45Km/h的速度来上学");
    }
}
class Truck extends Vehicle{
    @Override
    void start() {
        System.out.println("小车以90Km/h的速度来赚钱");
    }
}
class Person{
    void order(Vehicle v){
        v.start();
    }
}
public class Main {


    public static void main(String[] args) {
        Person p = new Person(); //在此处开辟空间，为了一会调用他们
      
        //下边的这两种方法是一样的，反而第二种还进行简便一些呢
        Car c = new Car();  //先将Car来进行实例化 来进行开辟空间
        p.order(c);
        p.order(new Car()); //直接来开辟空间
        p.order(new Truck());
        
    }
}

//抽象类的使用-----据说只是多加了一个抽象类,同时具有类的所有的功能

注意的是抽象类要添加关键字abstract的，同时不具有方法体

以及他只是说它具有啥功能，但是具体功能的实现全部是交给自己的子类去实现的

例题5.2
import java.util.Scanner;
//其实说到抽象的数据类型，我感觉最大的东西就是说，他可以去定义功能，但是需要自己的子类实现
abstract class Animal{
    String name;
    public abstract  void go(); //抽象的类是没有方法体的
    //这个时候设置子类如果没有实现的他的功能是要加前缀名abstract的
}
class Dog extends Animal{
    public Dog(String name){
        this.name = name; //这个改变的是那个父亲也就是Animal
    }
    public void go(){
        System.out.println(name+"can run");
     }
}
class Bird extends Animal{
    public Bird(String name){
        this.name = "李四"; //这个改变的是那个父亲也就是Animal
    }
    public void go(){
        System.out.println(name+"can run");
    }
}
class show{
    void show1(Animal x){
        x.go();
    }
    public void out111(){
        System.out.println("这个是调用第三方去将其全部的输出");
    }
}
public class Main {

    //问题？ 为啥说在抽象类中，如果将他的子类也设置抽象类不行吗？
    //行，但是抽象类就是相当于提供了功能，但是实践需要子类去完成，如果子类继续抽象
    //那就是子类的子类来完成，因为抽象类是不能实例化的，就是不能在main中定义
    //这就是为啥这里不能用 final 和static的 原因
    public static void main(String[] args) {
//        Dog dog = new Dog("张三");
//        dog.go();
        show w = new show();
        Dog dog = new Dog("张三");
        Bird bird = new Bird(""); //我不传入任何的值因为我前边已经定义好了
        w.show1(bird);
        w.show1(dog);
        w.out111();

    }
}

//接口的实现

其实和抽象类十分的相似但是还是有很多区别的

import java.util.Scanner;
//implement 和extends的区别是：
//implement是为了实现接口的操作
//这个是为了继承那个子父继承的关系
 interface PCI{
     void setName(String s); //在子窗口中被重写所重新定义
     void run();
}
  class VideoCard implements PCI{
     String name="微星";
     public void setName(String s){
         name=s;
     }
     public void run(){
         System.out.println(name+"显卡已经开始工作了");
     }
}
 class SoundCard implements PCI{
    String name="AC";
    public void setName(String s){
        name=s;
    }
    public void run(){
        System.out.println(name+"声卡已经开始工作了");
    }
}

class Mainboard{ //在此创建出自己的一个类
     public void interfacePCI(PCI p){  //多态的使用
         p.run();
     }
     public void run(){
         System.out.println("主板已经开始工作了");
     }
}
public class Main {

    public static void main(String[] args) {
Mainboard mb = new Mainboard(); //实例化
        VideoCard vc = new VideoCard();  //这个不是抽象的数据吗，不能实例化
        vc.setName("huawei");
        SoundCard sc = new SoundCard();
        mb.interfacePCI(vc);
        mb.interfacePCI(sc);
        mb.run();
    }
}

//完成老师课堂上演示的案例

import java.util.Scanner;
//这个相当于是一个小的练 习
abstract class Pet{ //采用抽象类哈
  abstract void feed();
  abstract  void use();

}
 class Dog extends Pet{
    void use(){
        System.out.println("小狗爱吃肉包子  汪汪汪！！！");
    }
    void feed(){
        System.out.println("给小狗喂食");
    }
}
class Cat extends Pet{
    void use(){
        System.out.println("我是小猫我爱抓老鼠");
    }
    void feed(){
        System.out.println("我爱吃猫粮");
    }
}
 class Person{ //创建人这个类
    String name;
   public Person(String names){
        this.name = names;
    }
    public void out111(){
       System.out.println(name+"开始喂食了");
    }
    public void feed(Pet pet){
        pet.feed();
    }
     public void use(Pet pet){
         pet.use();
     }

}
public class Main {
    public static void main(String[] args) {
      Pet pet;
      pet = new Dog();
      Person person = new Person("张三");
      person.out111(); //输出张三开始喂食了
      person.feed(pet); //小狗爱吃肉包子
      person.use(pet); //小狗看门
      System.out.println("---------------------------------");
      pet = new Cat(); //这个其实就是相当于你给他重新去赋予新的值
      person.feed(pet); //小猫吃东西
        person.use(pet);

    }
}