面向对象概念

类:类是一个模板，表示一类事物的行为和状态
对象:对象是类的一个实例，有自己状态和行为
类是对象的抽象，而对象是类的具体实例。

class Person{
    public String name;
    public int age;
    public static int legs=2；
    Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void eat(){
        System.out.println("吃饭");
    }
}
------------
Person zhangsan=new Person("张三",21);
Person lisi=new Person("李四",22);

Person是类类中有name和age属性默认是空的行为方法：eat
zhangsan和lisi分别是Person的一个具体的类，有自己的name和age，和类的行为方法eat

构造方法

顾名思义，非普通方法，具有构造功能，通过此方法可以构造对象

构造方法的方法名必须与类名一样。 
构造方法没有返回类型，也不能定义为void，在方法名前面不声明方法类型。  
构造方法主要作用是完成对象的初始化工作，他能够把定义对象时的参数传递给对象的域。  
构造方法不能由编程人员调用，而要系统调用。  
构造方法可以重载，以参数的个数，类型，或排序顺序区分。
当我们使用new Person("张三",21)时，实际上系统会自动调用 Person(String name,int age)构造方法

所有的构造方法，都要直接或者间接的调用父类的构造方法，因为先有父类才会有子类。
Object是所有类的直接或间接父类。上面的构造方法实际会隐式调用super() 即Obejct的空参数构造方法

    Person(String name,int age){
        super();//隐式调用
        this.name=name;
        this.age=age;
    }

类属性和对象属性

由static修饰的属性即类属性，没有static修饰即对象属性
类属性，可以通过类.属性名来引用也可以使用对象.属性名来引用不过推荐
对象属性必须通过对象.属性名来引用

Person zhangsan=new Person("张三",21);
Person lisi=new Person("李四",22);
zhangsan.age=30;//并不会影响李四的age
System.out.println(lisi.age);// 22
//Person有一个属性 public static int legs=2; 两只腿
zhangsan.legs=1;
//修改张三的腿数量 李四的同样会变 为避免不必要的麻烦，一般使用Person.legs来引用
System.out.prinln(lisi.legs);//1

类方法和对象方法

同属性一样，由static修饰的即类方法，没有则普通方法
类方法，可以通过类.方法名来引用也可以使用对象.方法名来引用不过推荐
对象方法必须通过对象.方法名来引用

继承和实现

子类是父类的一种，子类具有父类的属性和方法，同时还具备自己的属性和方法
子类是通过extends来实现的，java中只支持单继承。父类可以是一般类或者是抽象类，通过final修饰的类，不能被继承
抽象类:一种特殊的类，类中可以有抽象方法，抽象类不可被实例化

public abstract class Anim{
    public abstract void eat();//抽象方法
}

注：抽象类也可以没有抽象方法，唯一的作用是不让类被实例化

接口：一种特殊的抽象类

public interface Lived{
    void living();
}

接口中所有的方法都是抽象的并且是public的,所有的成员都是常量。从java8.0开始接口中可以定义默认方法默认方法子类不需要实现
实现接口通过implements 来实现，java中支持多实现。

public class Person extends Anim implements Lived{
   @Override
   public void living(){
        System.out.println("群居生活");
    }
   @Override
    public void eat(){
        System.out.println("每天吃三顿");
    }
}

一个类如果不是抽象的，必须实现所有接口的全部方法和父类的全部抽象方法

方法的重写和重载

重写:覆盖父类的方法，定义自己的实现。方法名，方法参数，返回值必须相同。子类方法的权限范围不能小于父类
重载:相同的方法，不同的参数。方法名相同，返回值可以不同。范围修饰符可以不同
重写只有父子类才会发生的。重载可以在一个类也可以在父子类

对象初始化流程

public class Test2 {
    public static void main(String[] args) {
        B b = new B();
        System.out.println("-------------------------");
        b = new B();
    }
    static class A {
        public String content = "AA";
        public static String text = "父类的Text";
        {
            System.out.println("父类代码块");
        }
        static {
            System.out.println("父类静态代码块");
        }
        A() {
            System.out.println("父类构造方法");
        }
    }
    public static class B extends A {
        public String con = "BB";
        public static String textA = "子类的Text";
        {
            System.out.println("子类代码块");
        }
        static {
            System.out.println("子类静态代码块");
        }
        B() {
            System.out.println("子类构造方法");
        }
    }
}

父类静态代码块
子类静态代码块
父类代码块
父类构造方法
子类代码块
子类构造方法
------------------------- 父类代码块
父类构造方法
子类代码块
子类构造方法

对象的初始化流程: 第一次创建对象
1.父类的静态变量和静态代码块
2.子类的静态变量和静态代码块
3.父类的普通变量和代码块
4.父类的构造方法
5.子类的普遍变量和代码块
6.子类的构造方法
第二次创建对象
1.父类的普通变量和代码块
2.父类的构造方法
3.子类的普遍变量和代码块
4.子类的构造方法

多态

父类引用指向子类对象，即同一类的引用可以表现不同行为。
例如:人继承动物
人可以指向动物即人对象指向动物引用，反过来说则不合适，动物不能指向人，因为动物不只是人。

public class Manager {
    public static void main(String[] args) {
        Anim anim = new Anim();
        System.out.println("anim--->name:" + anim.name);
        System.out.println("anim--->age:" + anim.age);
        anim.eat();
        anim.wan();
        System.out.println("----------------------");
        Anim pig = new Pig();
        System.out.println("pig--->name:" + pig.name);
        System.out.println("pig--->age:" + pig.age);
        pig.eat();
        pig.wan();
        System.out.println("----------------------");
        Anim dog = new Dog();
        System.out.println("dog--->name:" + dog.name);
        System.out.println("dog--->age:" + dog.age);
        dog.eat();
        dog.wan();
        System.out.println("----------------------");
        Dog dog2= (Dog) dog;
        System.out.println("dog--->name:" + dog2.name);
        System.out.println("dog--->age:" + dog2.age);
        dog2.eat();
        dog2.wan();
        dog2.sleep();
    }
    static class Anim {
        public String name = "动物";
        public static int age = 0;
        public void eat() {
            System.out.println("动物的eat方法");
        }
        public static void wan() {
            System.out.println("动物的静态 玩方法");
        }
    }
    static class Pig extends Anim {
        public String name = "小猪";
        public static int age = 5;
        @Override
        public void eat() {
            System.out.println("小猪的eat方法");
        }
        public static void wan() {
            System.out.println("小猪的静态 玩方法");
        }
    }
    static class Dog extends Anim {
        public String name = "小狗";
        public static int age = 3;
        @Override
        public void eat() {
            System.out.println("小狗的eat方法");
        }
        public static void wan() {
            System.out.println("小狗的静态 玩方法");
        }
        public void sleep(){
            System.out.println("小狗的 sleep方法");
        }
    }
}

输出结果:

anim--->name:动物
anim--->age:0
动物的eat方法
动物的静态 玩方法
----------------------
pig--->name:动物
pig--->age:0
小猪的eat方法
动物的静态 玩方法
----------------------
dog--->name:动物
dog--->age:0
小狗的eat方法
动物的静态 玩方法
----------------------
dog--->name:小狗
dog--->age:3
小狗的eat方法
小狗的静态 玩方法
小狗的 sleep方法

由上面代码运行结果可见: 普通变量，静态变量，静态方法看左侧
普通方法看右侧
父类引用指向子类对象，不能调用子类中声明而父类中没有声明的方法和变量

java基础二：面向对象