(面向对象2)对象与引用，static关键字，代码块，包，访问权限修饰符，封装，this关键字

对象与引用

Car car= new Car();
通常把这条语句的动作称之为创建一个对象，其实，它包含了三个动作。

1. 右边的“new Car()”，是以Car类为模板,调用Car类的构造函数,在堆空间里创建一个Car类对象。
2. 左边的“Car car”创建了一个Car类引用变量。所谓Car类的引用，就是以后可以用来指向Car对象的对象引用。
3. ”=”操作符使对象引用指向刚创建的那个Car对象。

我们可以把这条语句拆成两部分：
Car car;
car= new Car();
这样写，就比较清楚了，有两个实体：一是对象引用变量，二是对象本身。
new Car(); 这个语句在堆空间里创建了实体，尽管它们也是确确实实存在的实体，但是，我们看不见，也摸不着。
对象没有名字，也就没法直接访问它。我们需要通过对象引用来间接访问对象。
对象好比是一只很大的气球，但是我们抓不住它。引用变量是一根绳，可以用来系汽球。
Car car1; （1）创建一根绳子，一根还没有系上任何一个汽球的绳；
Car car2;（2）就又做了一根绳，还没系上汽球，
car1 = new Car();（3）给car1 系上气球；
car2 = car1 ；（4）这里，发生了复制行为。要说明的是，对象本身并没有被复制，被复制的只是对象引用。
结果是，car2也指向了car1所指向的对象。两根绳系的是同一只汽球。

基本类型和引用类型的区别

值传递与引用传递
Java中进行方法调用中传递参数时，参数传递有两种：

• 值传递：(形式参数类型是基本数据类型)：方法调用时，实际参数把它的值传递给对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。

• 引用传递：(形式参数类型是引用数据类型参数)：也称为传地址。方法调用时，实际参数是对象，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下来，所以方法执行中形式参数的改变将会影响实际参数。

  基本类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象本身 。

static关键字

static被称为静态，可以用来修饰类的属性,方法,代码块,内部类。
随着类的加载而加载
优先于对象存在
修饰的成员，被所有对象所共享
可不创建对象，直接被类调用
在代码中，静态代码块，实例代码块，构造方法同时存在时，
执行顺序为：静态代码块> 实例代码块> 构造方法

static属性
静态属性是类的所有对象共享的，即不管创建了多少个对象，静态属性在内存中只有一个。
static方法可以使用对象调用，也可以直接用类名调用，建议用类名直接调用
在static方法内部只能访问类的static属性，不能访问类的非static属性。

代码块

代码块在类中声明，类似一个没有名称的方法体(代码块)，代码分实例块和静态块
实例块：每次创建对象时自动调用
{
//任何符合语法的Java代码
}
静态块：类加载时自动调用，仅一次，与是否创建对象无关。
static {
//任何符合语法的Java代码
}

包

包的概念：
物理上是文件夹
管理类

包的作用：
避免类重名
按照不同功能管理类
控制访问权限

包（package）的命名规范：
在包名中，可以使用.号来区分包的级别；包名一般情况下是小写
第一级 指该项目的类型，如com,org,gov等，
第二级 指项目所开发或者运行的公司名称，如：oracle,sun,huawei等
第三级 指项目的名称，如：bcms,oa,erp,cms等
第四级 指项目模块的名称，如：bean,action,exception等

访问权限修饰符

Java语言有四个权限访问修饰符，权限从大到小依次为：
1）public ：公共权限 修饰类、属性、方法。可以被任意类访问
2）protected：受保护的权限 修饰属性、方法。
可以被同包类访问，如果不是同包类，必须是该类的子类才可以访问。
3）default：同包权限 修饰类、属性、方法。只能被同包的类访问
4）private：私有权限 修饰属性、方法。 只能在本类中访问

示例：

package day1;
public class Demo4 {

    public int num1=1;//公共权限  可以被任意类访问
    protected int num2=2;//受保护的权限  可以被同包类访问，如果不是同包类，必须是该类的子类才可以访问。
    private int num3=3;//私有权限 只能在本类中访问

    int num4=4;//同包权限 只能被同包的类访问
    public void num(){
        System.out.println(num1);
        System.out.println(num2);
        System.out.println(num3);
        System.out.println(num4);
    }
    public static void main(String[] args) {
        new Demo4().num();
    }
}







package day1;//与Demo4在同一个包
public class Demo5 {
    public void d5(){
        Demo4 demo5=new Demo4();
        System.out.println(demo5.num1);//公共权限  可以被任意类访问
        System.out.println(demo5.num2);//受保护的权限  可以被同包类访问，如果不是同包类，必须是该类的子类才可以访问。
                                        //num3  被私有权限修饰 只能在本类中访问
        System.out.println(demo5.num4);//同包权限 只能被同包的类访问

    }
    public static void main(String[] args) {
        new Demo5().d5();
    }
}






package day2;//与Demo4在不同的包中
import  day1.Demo4;
public class Demo6 extends Demo4{//类Demo6继承了Demo4,是Demo4的子类
    public void d3(){
        Demo6 d6=new Demo6();
        System.out.println(d6.num1);//公共权限  可以被任意类访问
        System.out.println(d6.num2);//受保护的权限  可以被同包类访问，如果不是同包类，必须是该类的子类才可以访问。
    }

    public static void main(String[] args) {
        Demo6 d6=new Demo6();
        d6.d3();
    }
}

面向对象特征–封装

封装的概念
在面向对象的程序设计中，封装就是把对象的属性和行为结合成一个独立的单位，并尽可能隐藏对象的内部细节（称为信息隐藏）。用户无需知道对象内部方法的实现细节，但可以根据对象提供的外部接口访问该对象。

封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问 .

封装的好处

具体表现
属性使用private权限
方法使用public权限

public class Demo{
    private String name;//属性使用private权限

    public void setName(String name){//方法使用public权限
                                     //别的类调用此方法可以给私有属性赋值
        this.name = name;
    }
    public String getName (){
        return name;
    }
}

this关键字

this关键字代表自身类的对象

• 使用this关键字引用成员变量
• 使用this关键字引用成员方法

注意：this关键字必须放在非静态方法里面

在一个类的方法或构造方法内部，可以使用“this.成员变量名”这样的格式来引用成员变量名，常常用来区分同名的成员变量和局部变量。

public class Demo{
    private int a;

    public Demo(int a){
        this.a = a;//等式左边this.a是引用成员变量名，右边a是传进来的值
    }

    public int getA(){
        return a;
    }

    public void setA(int a){
        this.a = a;
    }
}