敲代码+1day

写一个简单的继承。

package FuXi04;
/*
定义一个标准的学生类
 */
public class Student extends Person{


    public Student() {
    }

    public Student(String name, int age) {
        super(name,age);
    }

    //自定义有一个学习的方法
    public static void study(){
        System.out.println("我要学习");
    }
}

package FuXi04;
/*
定义的是一个标准的老师类
 */
public class Teacher extends Person{
    public Teacher() {
    }

    public Teacher(String name, int age) {

 1. List item

        super(name,age);
    }
    //自定义一个教书的方法
    public static void teach(){
        System.out.println("教书育人");
    }
}

package FuXi04;
/*
这是一个有关学生老师的父类
 */
public abstact class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = 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;
    }
}

package FuXi04;
/*
这是一个继承的测试类
 */
public class Test {
    public static void main(String[] args) {
        Student s=new Student();
        s.setName("小新") ;
        s.setAge(15) ;
        System.out.println(s.getName() +","+s.getAge() );
        s.study();

        Student s1=new Student("小明",28);
        System.out.println(s1.getName() +","+s1.getAge() );
        s1.study();
        Teacher t=new Teacher();
        t.setName("zhang") ;
        t.setAge(36) ;
        System.out.println(t.getName() +","+t.getAge() );
        t.teach();
        Teacher t1=new Teacher("陈",34);
        System.out.println(t1.getName() +","+t1.getAge() );
        Teacher.teach();//我设置的是静态方法所以可以通过类名调用
    }
}

8.多态：同一个对象在不同时刻表现出来的不同形态。
9.多态的前提和体现：有继承/实现关系；有方法重写；有父类引用指向子类对象。
10.多态访问成员时编译和执行都看左边即父类；访问对象时编译看左边，执行看右边。
11.多态不能使用子类的特有功能。

写一个简单的多态

package FuXi04;
/*
写一个父类，年龄、姓名、get、set方法等，eat方法
 */
public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = 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 abstract void eat();
}

package FuXi04;
/*
写一个猫类继承动物类
 */
public class Cat extends Animal{
    //重写方法
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }
}

package FuXi04;

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
    public Dog(){}

    public Dog(String name, int age) {
        super(name, age);
    }

}

package FuXi04;
/*
这是一个测试类
 */
public class Test1 {
    public static void main(String[] args) {
        Animal a=new Cat();//多态
        a.setName("加菲");
        a.setAge(7) ;
        System.out.println(a.getName() +","+a.getAge() );
        a.eat() ;
        //来一个向下转型
        Cat c=(Cat)a;//此时就可以调用父类中没有的方法
        Animal a1=new Dog("京巴",5);
        System.out.println(a1.getName() +","+a1.getAge() );
        a1.eat() ;
    }
}

12.抽象类中可以没有抽象方法，但抽象方法必须定义在抽象类中。抽象方法没有方法体。
13.抽象类的子类要么是抽象类，要么重写父类所有抽象方法。
14.接口是对行为的一种抽象。用关键字interface修饰，类实现接口用implements，
15.接口中只能定义常量。默认修饰符public static final
16.成员方法只能是抽象方法，默认修饰符public abstract
17.接口没有构造方法。
明天再写啦，今天好累…