面向对象的三大特性

一、封装

1. 封装是指类内部数据操作需要自己完成，不允许外部干涉，仅暴露少量的方法供外部使用。
2. 数据的隐藏：禁止直接访问一个对象中数据的实际表示，而应该通过操作接口来访问
3. 类中的属性私有，通过set/get方法获取数据

public class Apprication {
    public static void main(String[] args)
    {
        Pet dog=new Pet();
        dog.setAge(4);
        System.out.println(dog.getAge());
        dog.setName("huang");
        System.out.println(dog.getName());
    }
}
public class Pet {
   private String name;
   private int age;
     public void setAge(int age) {
        if(age<0||age>120)
        {
            System.out.println("输入数据不合法!");
        }else {
            this.age = age;
        }
    }
    public int getAge() {
        return age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

• 封装的意义
  1.提高代码的安全性，保护数据
  2.隐藏代码的实现细节
  3.统一接口
  4.增加系统的可维护性

二、继承

1. 继承的本质就是某一批类的抽象，从而对实现对现实世界的建模
2. 继承用到的关键词是extends
3. java中只有单继承，没有多继承
4. 继承是类与类之间的一种关系
5. 子类（派生类）继承父类（基类）
6. 在java中所有的类都默认直接或间接继承object类（可以省略不写）

• super的使用

public class Animals {
    protected String name="animals";
    public Animals()//构造方法
    {
        System.out.println("执行了父类的无参构造法");
    }
    public void print()//若使用private则会报错,私有的东西无法被继承
    {
        System.out.println("Animals");
    }
}

public class Pet extends Animals {
    private String name="pet";
    public Pet()
    {
//      this();与super()方法一样
        super();//隐藏代码,调用父类的无参构造,只能放在子类构造方法的第一行
        System.out.println("执行了子类的无参构造方法");

    }
    public void print()
    {
        System.out.println("pet");
    }
    public void test1(String name)
    {
        System.out.println(name);//xiao
        System.out.println(super.name);//animals
        System.out.println(this.name);//pet
    }
    public void test2()
    {
        print();//pet
        this.print();//pet
        super.print();//Animals
    }
}

public class Apprication {
    public static void main(String[] args)
    {
        Pet dog=new Pet();
        dog.test1("xiao");
        dog.test2();
    }
}

/*
执行了父类的无参构造法
执行了子类的无参构造方法
xiao
animals
pet
pet
pet
Animals
*/

• 注意点
  1.super调用父类的构造方法，必须在构造方法的第一行
  2.必须只能出现在子类的方法或构造方法
  3.super和this不能同时调用构造方法

this:本身调用者这个对象，没有继承也可以使用
super:代表父类对象的应用，只能在继承条件下才可以使用
this():本类的构造方法
super():父类的构造方法

• 方法的重写

重写：需要有继承关系，子类重写父类的方法
1.方法名必须相同
2.参数列表必须相同
3.修饰符范围可以扩大但是不能缩小：public>protected>default>private
4.抛出的异常：范围可以被缩小但是不可以扩大：ClassNotFountException–>Exception(范围大)

public class B {
    public  void test()
    {
        System.out.println("父类");
    }
}

public class A extends B{
    public  void test()
    {
        System.out.println("子类");
    }
}

public class Aprication {
    public static void main(String[] args)
    {
        A a=new A();
        a.test();//子类

        //若是静态方法，则方法的调用只跟左边定义的类型有关，与new无关
        //若是非静态方法，则有关，是方法的重写
        B b=new A();//父类的引用即b可以指向子类
        b.test();//子类
    }
}

public class B {
    public static void test()
    {
        System.out.println("父类");
    }
}

public class A extends B{
    public static void test()
    {
        System.out.println("子类");
    }
}

public class Aprication {
    public static void main(String[] args)
    {
        A a=new A();
        a.test();//子类

        //若是静态方法，则方法的调用只跟左边定义的类型有关，与new无关
        //若是非静态方法，则有关为方法的重写
        B b=new A();//父类的引用即b可以指向子类
        b.test();//父类
    }
}

三、多态

理解：同一个方法可以根据发送对象的不同而采用多种不同的方式

public class Apprication {
    public static void main(String[] args)
    {
        //一个对象的实际类型是确定的，但是引用的类型不确定：父类指向子类
        Students s1=new Students();
        Person s2=new Students();
        Object s3=new Students();

        //Students能调用的都是自己的或是继承父类的
        //Person不能调用子类独有的方法
        //子类重写了父类的方法则会执行子类的方法
        s2.run();//son
        s1.run();//son
        //对象能执行什么方法主要是看左边的类型
    }
}
public class Person {
    public  void run()
    {
        System.out.println("执行");
    }
}

public class Students extends Person {
    @Override
    public void run() {
        System.out.println("son");
    }
}

多态的注意事项：

1.多态是方法的多态，属性没有多态
2.父类和子类有联系，类型转换异常
3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象
4. static方法属于类，它不属于实例，不可重写，final常量不可重写，private方法也不可重写

• instanceof

public class Apprication {
    public static void main(String[] args)
    {
      Object o=new Students();
        System.out.println(o instanceof Students);//ture,表示o属于Students类型
        System.out.println(o instanceof Person);//true，表示o属于Person类型
        System.out.println(o instanceof Object);//true,表示o属于Object类型
        System.out.println(o instanceof Teachers);//false,表示o不属于Teachers类型

      Person p=new Students();
        System.out.println(p instanceof Students);//ture,表示p属于Students类型
        System.out.println(p instanceof Person);//true，表示p属于Person类型
        System.out.println(p instanceof Object);//true,表示p属于Object类型
        System.out.println(p instanceof Teachers);//false,表示p不属于Teachers类型
    }
}

• 类型转换

  public static void main(String[] args)
    {
      Person p=new Students();//父类转换成子类需要强制转换,
      Students s=(Students)p; //强制转换
      s.run();//转换后才可以调用子类的方法
    }
//子类自动可以转换成父类但是可能会丢失一些方法