面向对象2

对象与引用

前面我们也讲过，Java中的变量分为基本类型和引用类型，而Java中的对象正是通过引用对其操作的。

举个例子：

class Car{
        int money;
        String name;
    }
    Car c1=new Car();

这条语句就是简单的创建了一个对象。而这其中，其实包含了三个动作。

1.等号左边Car c1指的是创建了一个Car类型的一个引用变量。而c1 便是对象名称。

2.等号右边new Car() 其实是以Car类为模板，在堆空间里面创建了一个Car类的对象。

3.“=”便是使对象引用指向刚创建的那个对象。

之所以给对象赋予一个名字，是因为这个语句是在堆空间中创建了实体，但是我们却摸不见看不着。所以一次来通过对象引用来间接的访问对象。

顺着讲完对象的引用我们刚好来讲

值传递与引用传递

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

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

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

总结一句话就是基本类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象
本身 。

我们举个例题来解释一下：

public static void main(String[] args) {
         int a  = 10;
         new Demo2().test(a);
        System.out.println(a);
    }

    public  void test(int b){
          b=20;
    }

这里最后输出a的值是10。便代表了值传递中，方法执行形参的改变不影响实参的值。

public static void main(String[] args) {
        Car car1 = new Car();
            car1.name = "宝马";
         new Demo3().test(car1);//引用类型实际不是传对象本身,传对象的地址
        System.out.println(car1.name);//奔驰
    }

    public  void test(Car car2){
        car2.name= "奔驰";
    }

这里最后输出car1.name的值是奔驰。便代表了在引用传递中，引用test()方法，而其中的形参改变只是指向了原来的形参，所以原方法中的实参没有改变。

this关键字

我们在前一篇中，浅浅的提了一下this关键字，这里我们深讲一下。

this的用法其实就这三点：

1.this关键字代表当前对象
2.使用this关键字引用成员变量
3.使用this关键字引用成员方法

int num;
    String name;
    public Demo(int num,String name){
        this.num=num;
        this.name=name;
    }
    Demo d1=new Demo(3,"jack");

如图所示，this也常常用作区分同名的成员变量和局不变量。

值得一提的是，如果名称不相同的话，其实可以不用this。

static关键字

static被称为静态，可以用来修饰类的属性，方法，代码块，内部类。

简要的说static有以下四个特点：

1.随着类的加载而加载，只有一份，在类加载的时候就可以使用了，在方法区内存储。
2.优先于对象存在，先加载类，而后才创建对象。
3.修饰的成员，被所有对象所共享。
4.可不创建对象，直接被类调用。

静态属性是类的所有对象共享的，即不管创建了多少个对象，静态属性在内存
中只有一个。

static方法可以使用对象调用，也可以直接用类名调用，建议用类名直接调用。
在static方法内部只能访问类的static属性，不能访问类的非static属性,static属性先加载。

以下我们举个实例，来理解以下概念。

 

 

 这里因为国家是两个人都相同的变量，所以使用的是static修饰，通常静态变量在定义的时候直接赋值就好。

我们会发现在用对象d1调用静态变量country时，是调用不出来的，但其实是可以使用的。不过我们通常建议使用本类来调用静态变量。

 在静态方法中非静态的变量是不能使用的。这是因为静态的变量是随着类加载而加载，而非静态的是服务于对象的。类加载后是不一定就有对象的，所以静态先与非静态。

 但是非静态的是可以访问静态的。

代码块

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

 举个栗子：

我们先定义一个非静态变量一个静态变量 。一个实例代码块一个静态代码块。

这里会发现static代码块中无法调用非静态变量a。所以我们注释掉她。

 

 我们用主方法调用两次方法来做实验。

 

 这里我们会看到，静态代码块在实例代码块的下面，可是运行结果却是静态代码块先运行出来。并且，调用了两次，静态代码块里的内容只出现了一次。

包

实际上看过你的IDEA文件夹中，你就会发现你的包其实就类似于文件夹一样表示在那里。

 

 

包呢是为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。

包的作用分为三点：

1.避免类重名
2.按照不同功能管理类
3.控制访问权限

全类名就是=包名+类的简称。

除此之外呢，包的命名应该全是小写的。

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

 包可以更好得管理逻辑相关的类，可以控制不同包之间的访问权限

 导入外部包的类，关键字“import”

例如我们之前使用Scanner时就是导的java给我们提供的工具包。

import java.util.Scanner;

学习了包的概念之后，我们以后就可以合理的规划自己的工作空间了。

访问权限修饰符

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

 还是一样我们通过实例，可以更好地将知识点记住。

 这里我们看到，四种访问权限修饰符修饰过的整数类型数在本类中都是能调用的。

 而在同包内的不同类中，私有权限的private就不能被调用了。

 这里我们引入一个继承的概念，之后就会讲到。上图中我们新建了一个包中使用继承extends继承了Demo类之后调用发现默认的defaul修饰符已经无法使用了。而Demo3类作为Demo类的子类也是可以使用protected修饰符所修饰的变量的。

 最后一种情况，public修饰符修饰的变量，即使是在父类中也是可以直接使用的，而这时protected修饰符修饰的变量pro已经无法被调用了。

面向对象特征

面向对象语言的三大特征就是：

封装、继承、多态。

面向对象特征——封装

我们先来讲三大特征之中的封装。

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

而封装的好处有四点：

1.只能通过规定方法访问

2.隐藏类的实现细节

3.方便加入控制语句

4.方便修改实现

举个栗子：

假设我们定义的一个值，如果没有对其封装，那么在别的类中我就可以改变它原有的值。

此刻只能进行不同的访问权限。

public class Demo{
private String name;
public String getName (){
return name;
}
public void setName(String name){
this.name = name;
}
}

好了今天就先讲这么多，讲的多了来不及消化也不行。