访问符，范围修饰符：

                                 public (公开)

                                 protected  (保护)

                                 无

                                 private (私有)

修饰符	本类中	同包类	同子类	外包类	外包子类
public（公开的）	√	√	√	√	√
protected  (保护)	√	√	√	X	√
无	√	√	√	X	X
private (私有)	√	X	X	X	X

封装：

         在平常的对象的变量有几个问题：

                                                          1.可以直接对属性赋值，只要不违反属性类型的大小即可

                                                          2.可以直接访问属性

                                                          3.赋值后，没有任何代码执行

封装就可以很好的解决：

                                    面向用户更简单，面向属性更安全

                                    1.将属性私有化

                                    2.你可以提供两个方法 一个set 设置  一个 get 得到的意思

封装方法介绍：

                      set方法：

                                   1.可以设置属性值

                                   2.验证数据的合法性

                                   3.执行业务逻辑

public class Dog {    private int age;//首先属性要私有化    public void setAge(int age) {        if (age > 0) {//在封装的数据中可以加入判断        this.age=age;        } else {            System.out.println("请输入您正确的年龄");        }    }}

get方法：

              1.可以得到属性值

              2.数据的加工

public class Dog {    public static void main(String[] args) {        Dog dog = new Dog();        dog.setAge(12);        int a = dog.getAge();        System.out.println(a);    }    private int age;//首先属性要私有化    public void setAge(int age) {        if (age > 0) {//在封装的数据中可以加入判断            this.age = age;        } else {            System.out.println("请输入您正确的年龄");        }    }    public int getAge() {        return (this.age / 2);//通过get方法取值，也可以数据加工    }}

继承：extends（继承关键字）

         代码高效率复用?

                                  继承等于拥有，子类继承父类 拥有父类的一切

                                  继承就是在父类的基础上扩展和升级

                                  从代码角度理解继承，其实他只是一个代码的复用.

         继承的好处：

                            除了私有成员不可访问，其他的都可以访问

                            拥有父类对象

                            父类的方法也一并在子类显示

public class Dog1 extends Dog {    public static void main(String[] args) {        Dog1 dog1 = new Dog1();//子类拥有父类的一切        dog1.x();        dog1.y();    }    public void z() {        System.out.println("啦啦");    }}———————————————————————————public class Dog2 extends Dog1 {    public static void main(String[] args) {        Dog2 dog2 = new Dog2();        dog2.x();        dog2.y();        dog2.z();    }    public void q() {        System.out.println("嘿嘿");//可以在前面的父类的基础上进行升级    }}

创建子类对象，先出父类对象后出子类对象

                                                                因为先把父类内存创建 然后 将子类内存覆盖

                                                                调用子类时是拥有父类内存的

规则（永远不会改变）：

                                   创建子类对象，先出父类后出子类

                                   使用子类对象调用方法，先问子类有没有，如果没就调用父类

                                   java中只能单一继承

                                   extends 后面只能写一个类

方法重写(覆盖父类的方法)： 

                                         就是子类觉得父类的方法不好用，或者有问题，就在子类申请了一个方法进行覆盖，这就叫重写

                                        与父类的方法声明一模一样

                                        你如果怕写错，你可以写一个注解在方法上 @Override这样就不会出错了

public class Dog {    public void x() {        System.out.println("嘻嘻哈哈");    }    public void y() {        System.out.println("啦啦啦");    }}____________________________________________________public class Dog1 extends Dog {    public static void main(String[] args) {        Dog1 dog1 = new Dog1();//子类拥有父类的一切        dog1.x();        dog1.y();    }    @Override    public void x(){        System.out.println("嘿嘿");    }    public void z() {        System.out.println("啦啦");    }}

super:

          代表父类对象(用super代表调用父类的，方法，变量等)

用法:

         1.父类对象

         2.选择父类构造器                                                  

final：

         修饰在类上  不能继承

        修饰在方法上  方法不可重写

        修饰在属性上 属性是常量  是常量就把它写成 static final 就行了

final public class T1 {//此类不可继承     static  final int a=1;//此只不会变    final public void a() {    }//此方法不可重写}

多态 (设计者身份)：

                            以父类做模板，子类做实现（面向父类编程）。

                            子类对象可以转换成父类类型

                            父类  a=new 子类()

                            面向父类编程：父类声明相应的方法，让子类去重写

                            硬代码：软编码可以在运行时确定，修改

                              软代码：而硬编码是不能够改变的。

                              父类转换成子类，切记一定里面是子类才行

                              父类转子类要强制转换

                              子类转父类自动转换

public class T1 {//此类不可继承    public void chi() {    }    public void he() {    }}------------------------------------------------------------------------------------------------------public class T2 extends T1 {    public static void main(String[] args) {        T1 t1 = new T2();        t1.chi();//子类转换父类是直接转换的    T2 t2= (T2) new T1();//子类转换父类需要强制转换    }    @Override    public void chi() {        System.out.println("哈哈");    }    @Override    public void he() {        System.out.println("呼呼");    }}