Java成员变量和局部变量的定义和使用、面向对象中封装和继承的相关特性

（1） 在Java语言中，根据定义变量的位置不同，可以将变量分成两大类；成员变量和局部变量。 （2）成员变量 成员变量包括类变量（用static修饰的变量）和实例变量（不用static修饰的变量） 一个类在使用之前要经过类加载、类验证、类准备、类解析、类初始化等几个阶段 类变量： 类变量在类准备阶段起开始存在，直到系统完全销毁这个类。类变量属于类，并且与类共存亡，类变量在内存中有且只有1份，通过类名.类变量 来调用。 实例变量： 实例变量在类的实例创建时开始存在，直到系统完全销毁这个实例。实例变量属于对象，通过对象.实例变量类当用，当然类变量也可以使用对象.类变量来访问。 但是需要注意的是，通过对象.实例变量调用实例变量的过程中，该实例变量仍然属于类，而不属于当前的对象 如：

package cn.bytecollege.variable;

/**

* 学生类 *

@author Ray

* */

public class Student

{

//静态成员变量 班级

public static String grade;

    }
        
    package cn.bytecollege.variable;
    /**
    * 测试类
    * @author Ray
    *
    */
    public class Test {
​
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            //为类变量grade赋值
            Student.grade = "三班";
            //创建对象student1
            Student student1 = new Student();
            //创建对象student2
            Student student2 = new Student();
            //通过对象.类变量的方式调用静态变量并修改值 该静态变量属于全体对象
            student1.grade = "一班";
            System.out.println(student2.grade);//输出：一班
        }
​
    }

（3）局部变量

    1. 分支结构内定义的变量
    2. 循环结构内定义的变量
    3. 方法内定义的变量
    4. 方法参数列表中的变量
    5. 代码块中定义的变量
    所有局部变量的作用范围都是离定义变量最近的大括号内
    如：
        package cn.bytecollege.variable;
        public class Test1 {
​
            /**
            * 测试类
            * @param args
            */
            public static void main(String[] args) {
                // TODO Auto-generated method stub
    
                //定义字符数组charArray
                String[] stringArray = new String[4];
                //for 循环中的循环变量就是局部变量
                for(int i=0;i<stringArray.length;i++) {
                    if(i%2==0) {
                        //if分支结构中 s1是局部变量
                        String s1 = "[(";
                        stringArray[i] = s1;
                    }else {
                        String s1 = ")]";
                        stringArray[i] = s1;
                    }
                }               
                //输出数组
                for(int i=0;i<stringArray.length;i++) {
                    System.out.print(stringArray[i]);//输出:[()][()]
                }
            }
        }

（4）面向对象的特征

  面向对象的三大特征∶封装、继承和多态
  1、封装：
          封装是指将对象的状态信息隐藏在对象的内部，不允许外部程序直接访问，只能通过对象内部提供的方法来实现对内部信息的操作和访问。
          为实现良好的封装，需要从两个方面考虑：
          将对象的成员变量和实现细节隐藏在对象内部，不允许外部直接访问
          把方法暴露出来，让方法来控制对这些成员变量进行安全的访问和操作
​
          访问修饰符：
                        public  protected    default   private
          同类             √         √        √          √
          同包子类         √         √        √          ×
          同包非子类       √         √        √          ×
          非同包子类       √         √        ×          ×
          非同包非子类     √         ×        ×          ×
          如：
            /**
            * 父类
            * @author Ray
            *
            */
            public class ParentClass {

                /**
                * 构造器
                */
                public ParentClass() {
    
                }
​
                //访问修饰符为public的变量 姓名
                public String publicName;
                //访问修饰符为protected的变量 存款
                protected String protectedMoney;
                //访问修饰符为default的变量 年龄
                int defaultAge;
                //访问修饰符为private的变量 性别
                private String privateGender; 
​
            }
            
            /**
            * 同包子类
            * @author Ray
            *
            */
            public class SonClass extends ParentClass{
                public void test() {
                    System.out.println(this.publicName);
                    System.out.println(this.protectedMoney);
                    System.out.println(this.defaultAge);
                    //System.out.println(this.privateGender) 不能访问;
                }
            }
​
            /**
            * 同包非子类
            * @author Ray
            *
            */
            public class Test {
​
                public static void main(String[] args) {
                    ParentClass parentClass = new ParentClass();
                    System.out.println(parentClass.publicName);
                    System.out.println(parentClass.protectedMoney);
                    System.out.println(parentClass.defaultAge);
                    //System.out.println(parentClass.privateGender); 不能访问
                }
            }       
​
            /**
            * 非同包子类
            * @author Ray
            *
            */
            public class SonClass extends ParentClass{
                public void test() {
                    System.out.println(this.publicName);
                    System.out.println(this.protectedMoney);
                    //System.out.println(this.defalutAge);  不能访问
                    //System.out.println(this.privateGender); 不能访问 
                }
​
            }
​
            /**
            *非同包非子类
            * @author Ray
            *
            */
            public class Test {
                public static void mian(String[] args) {
                    ParentClass parentClass = new ParentClass();
                    System.out.println(parentClass.publicName);
                    //System.out.println(parentClass.protectedMoney); 不能访问
                    //System.out.println(parentClass.defaultAge); 不能访问
                    //System.out.println(parentClass.privateGender); 不能访问
                }
            }
​
          总结:
            public:公共的，任意位置都可以访问
            protected:同包和子类（同包子类，同包非子类，非同包子类）
            缺省：同包（同包子类，同包非子类）
            private：私有,类内
          包：
            1. 从操作系统层面来看，包就是一个文件夹或者路径
            2. 从项目开发角度来看，包可以有效的管理类
            3. Java中引入包概念，目的是为了解决类名冲突的问题，不同包下可以有同名的类。如果某个类在某个包中，那么在类中代码的第一行一定要声明类所在的包：package packageName
            4. 包的命名一般使用域名的倒置例如：cn.bytecollege.util
            5. Java中定义一个类，会默认导入java.lang包
          常用的包：
            java.io：输入输出流
            java.lang：通用包
            java.lang.reflect：反射相关
            java.math:数学相关
            java.text：格式化相关
            java.util：集合框架相关
            java.sql：数据库相关
 2、继承：
        在已有类的基础上创建一个新类，从而达到代码复用的目的，已有的类又叫做基类，父类，或者超类，父类中定义的是通用的状态和行为，新建的类又叫做子类或者派生类。继承使用extends关键字实现，Java中继承是单继承的，一个类有且只能又一个父类。Java中所有的类都是Object的子类，每个类都会直接或者间接继承Object。
        方法重写（override）:
            当子类从父类继承的方法不能满足子类需要时，子类可以对父类的方法进行重写，也叫方法覆盖
        方法重写的特征:
​
            1. 方法重写只存在于继承关系中
            2. 方法名相同参数列表相同
            3. 返回类型和父类方法返回值类型一致或者是父类方法的返回值类型的子类
            4. 访问修饰符权限大于等于父类方法访问修饰符权限
            5. 子类方法抛出异常小于等于父类方法抛出异常