继承，多态，接口，内部类

继承

package extend;

public class People {
    public int age=20;

    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    public People(){
        System.out.println("父无参");
    }
    public People(int age){
        System.out.println("父有参");
    }
    public void show(){
        System.out.println("父类方法");
    }
    /*
    fianl关键字的作用
        fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）
        final修饰方法：该方法不能被重写
        final修饰变量：表明该变量是一个常量，不能再次赋值
    fianl修饰基本数据类型变量
        final 修饰指的是基本类型的数据值不能发生改变
    final修饰引用数据类型变量
        final 修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的
    */
    /*
    static修饰的特点:
        1. 被类的所有对象共享，这也是我们判断是否使用静态关键字的条件
        2. 可以通过类名调用当然，也可以通过对象名调用【推荐使用类名调用】
    static的访问特点
        非静态的成员方法
            * 能访问静态的成员变量
            * 能访问非静态的成员变量
            * 能访问静态的成员方法
            * 能访问非静态的成员方法
        静态的成员方法
            * 能访问静态的成员变量
            * 能访问静态的成员方法
    总结成一句话就是：
        静态成员方法只能访问静态成员
    */
}

package extend;

public class Student extends People{
    public int height=180;
    public int age=50;

    public int getHeight() {
        return height;
    }
    public void setHeight(int height) {
        this.height = height;
    }
    @Override
    public int getAge() {
        return age;
    }
    @Override
    public void setAge(int age) {
        this.age = age;
    }

    public Student(){
        //super();(默认)
        System.out.println("子无参");
    }
    public Student(int age){
        //super();(默认)
        System.out.println("子有参");
    }
    @Override   //方法重写声明
    public void show(){
        int age=100;
        /*
           在子类方法中访问一个变量(访问成员方法类似):(例子:age)
           子类局部范围找;
           如果没有，则在子类成员范围找;
           如果没有，则在父类成员范围找;
           如果都没有，则报错
         */
        System.out.println(age);
        System.out.println(this.age);   //访问本类的成员变量
        System.out.println(super.age);  //访问父类的成员变量
        System.out.println(height);
    }
}

package extend;

public class test {
    public static void main(String[] args) {
        //子类中所有的构造方法默认都会访问父类中无参的构造方法
        Student st1=new Student();
        System.out.println("-----------------");
        Student st2=new Student(20);
        //st.show();
    }
}

多态

package duo;

public 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 void eat(){
        System.out.println("动物吃饭");
    }
}

package duo;

public class Dog extends Animal{
    public Dog() {
    }
    public Dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("狗吃饭");
    }
}

package duo;

public class Cat extends Animal{
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("猫吃饭");
    }
}

package duo;

public class Demo {
    public static void main(String[] args) {
        Animal dog=new Dog("狗",18);
        Animal cat=new Cat("猫",20);
        dog.eat();
        cat.eat();
    }
}

接口

package duo;

/*抽象类和接口的区别
- 成员区别
  - 抽象类
    ​	变量,常量；有构造方法；有抽象方法,也有非抽象方法
  - 接口
    ​	常量；抽象方法

- 关系区别
  - 类与类
    ​	继承，单继承
  - 类与接口
    ​	实现，可以单实现，也可以多实现
  - 接口与接口
    ​	继承，单继承，多继承

- 设计理念区别
  - 抽象类
    ​	对类抽象，包括属性、行为
  - 接口
    ​	对行为抽象，主要是行为
*/

public abstract class People {
    public String name;
    public int age;

    public People() {}
    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }
    int i=10;

    public abstract void show();
}

package duo;

public class Student extends People{
    public Student() {
    }

    public Student(String name, int age) {
        super(name, age);
    }
    @Override
    public void show() {
        System.out.println("我是学生");
    }
}

package jie;

public interface Animal {
    /*接口的成员变量
    * 只能是常量
    * 默认修饰符: public static final
    */
    int i=10;   //public static final int i=10;
    public void eat();
}

package jie;

public class Dog implements Animal{
    @Override
    public void eat() {

    }
}

package jie;

public interface Inter1 {
}

package jie;

public interface Inter2 {
}

package jie;

public interface Inter3 extends Inter1,Inter2{

}

package jie;

/*
 * 类与类的关系
 *   ​	继承关系，只能单继承，但是可以多层继承
 * 类与接口的关系
 *   ​	实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
 * 接口与接口的关系
 *   ​	继承关系，可以单继承，也可以多继承
 */


public class Demo extends Object implements Inter1,Inter2,Inter3 {

}

内部类

package inclass;

/* 内部类的访问特点
* 内部类可以直接访问外部类的成员，包括私有
* 外部类要访问内部类的成员，必须创建对象
*/
public class Demo1 {
    private int i=10;
    /*public class test{
         public void show1(){
             System.out.println(i);
         }
    }*/
    //成员内部类
    private class test{
        public void show1(){
            System.out.println(i);
        }
    }
    public void show2(){
        test t=new test();
        t.show1();
    }
}

package inclass;

public class Demo2 {
    public int num=999;
    public void method(){
        //局部内部类
        class test{
            public void show(){
                System.out.println(num);
            }
        }
        test t=new test();
        t.show();
    }
}

package inclass;

public interface Inter {
    void  show();
}

package inclass;

public class Demo3 {
    public void method(){
       /* new Inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        }.show();*/
        //匿名内部类
        Inter i=new Inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };
        i.show();
    }
}

package inclass;

public class test {
    public static void main(String[] args) {
        //Demo1.test dt=new Demo1().new test();
        //dt.show1();
        Demo1 d1=new Demo1();
        d1.show2();
        Demo2 d2=new Demo2();
        d2.method();
        Demo3 d3=new Demo3();
        d3.method();
    }
}