java基础二：面向对象

面向对象概念

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

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方法
复制代码

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