Java 面向对象,对象创建和使用

面向对象描述

　　优点：耦合度低，扩展力强，更符合人类的思维方式

　　OOA 面向对象分析； OOD 面向对象设计 ；OOP 面向对象编程

面向对象包括三大特征

　　封装 、继承、多态

类和对象的概念　　

什么是类？
　　类实际上在现实世界当中是不存在的，是一个抽象的概念。
　　是一个模板。是我们人类大脑进行“思考、总结、抽象”的一个
　　结果。(主要是因为人类的大脑不一般才有了类的概念。)

　　类本质上是现实世界当中某些事物具有共同特征，将这些共同
　　特征提取出来形成的概念就是一个“类”，“类”就是一个模板。

　　明星是一个类

什么是对象？
　　对象是实际存在的个体。（真实存在的个体）

　　宋小宝就是一个对象

在java语言中，要想得到“对象”，必须先定义“类”，“对象”是通过“类”这个模板创造出来的。

　　类就是一个模板：类中描述的是所有对象的“共同特征信息”对象就是通过类创建出的

这几个术语你需要自己能够阐述出来：
　　类：不存在的，人类大脑思考总结一个模板（这个模板当中描述了共同特征。）
　　对象：实际存在的个体。
　　实例：对象还有另一个名字叫做实例。
　　实例化：通过类这个模板创建对象的过程，叫做：实例化。
　　抽象：多个对象具有共同特征，进行思考总结抽取共同特征的过程。

　　类 --【实例化】--> 对象(实例)
　　对象 --【抽象】--> 类

类是一个模板，是描述共同特征的一个模板，那么共同特征包括什么呢？

　　类 = 属性 + 方法

　　属性来源于：状态

　　方法来源于：动作

类的定义

　　1、怎么定义一个类，语法格式是什么？　　　　

　　　　　　[修饰符列表] class 类名 {
　　　　　　　　//类体 = 属性 + 方法
　　　　　　　　// 属性在代码上以“变量”的形式存在（描述状态）
　　　　　　　　// 方法描述动作/行为
　　　　　　}

　　2、为什么属性是“以”变量的形式存在的？

　　　　是因为属性对应的是“数据”，数据在程序中只能放到变量中。

对象和引用

　　

 

 

画内存图

　　

　　

public class User{
    // 用户id
    // 访问id不能这样：User.id （这是错误的，实例变量不能用类名访问。）
    // id的访问必须先造对象，然后对象有了，才能访问对象的id
    int id; //成员变量，实例变量（对象变量，一个对象一份。）
    // 用户名
    String username; // 成员变量可以不手动赋值，系统赋默认值。
    // 密码
    String password;
}

// 第一步：类加载
// 第二步：调用UserTest类的main方法（方法调用要压栈。）
public class UserTest{

    // 方法体外声明的变量叫做成员变量。
    //User u1; //成员变量。（实例变量）

    public static void main(String[] args){
        //int i = 100;

        // 方法体当中声明的变量叫做局部变量
        User u1 = new User();
        // 实例变量怎么访问（属性怎么访问）？
        // 语法是：“引用.属性名”
        System.out.println(u1.id); //0
        System.out.println(u1.username); //null
        System.out.println(u1.password); //null

        u1.id = 11111;
        u1.username = "zhangsan";
        u1.password = "123";

        System.out.println(u1.id);
        System.out.println(u1.username);
        System.out.println(u1.password);
        
        User u2 = new User();
        u2.id = 22222;
        u2.username = "lisi";
        u2.password = "456";

        System.out.println(u2.id);
        System.out.println(u2.username);
        System.out.println(u2.password);
    }
}

　　第二个

　　

// 住址类
public class Address{

    // 一个家庭住址有3个属性。

    // 城市
    String city; // 实例变量

    // 街道
    String street;

    // 邮编
    String zipcode;
}

public class User{

    // 类=属性+方法
    // 以下3个都是属性，都是实例变量。（对象变量。）

    // 用户id
    // int是一种基本数据类型
    int id; // 实例变量

    // 用户名
    // String是一种引用数据类型
    String username; // 实例变量

    // 家庭住址
    // Address是一种引用数据类型
    // addr是成员变量并且还是一个实例变量
    // addr是否是一个引用呢？是。addr是一个引用。
    Address addr; 
}

/*
    到目前为止，如果什么也没听懂，怎么写代码？
        记住一个知识点就行，可以后期慢慢学习画图。
            记住一句话：里面有什么就能“点”什么。

            所有的实例变量（属性）都是通过“引用.”来访问的。
    
    引用和对象怎么区分？
        “引用”是啥？是存储对象内存地址的一个变量。
        “对象”是啥？堆里new出来的。
    
    通俗一点：
        只要这个变量中保存的是一个对象的内存地址，那么这个变量就叫做“引用”。
    
    思考：
        引用一定是局部变量吗？
            不一定。
*/
public class Test{
    public static void main(String[] args){

        //报错了。id是实例变量，必须先创建对象，通过“引用.”的方式访问。
        /*
            User u = new User();
            u是引用。
        */
        //System.out.println(User.id);

        

        /*
        int i = 100;
        int j = i; // 原理：会将i中保存的100复制一份，传给j变量。
        */
        
        // 家庭住址对象
        Address a = new Address();
        a.city = "北京";
        a.street = "大兴区";
        a.zipcode = "121221";
        
        // 用户对象
        User u = new User();
        System.out.println(u.id); // 0
        System.out.println(u.username); // null
        System.out.println(u.addr); // null

        u.id = 11111;
        u.username = "zhangsan";
        u.addr = a;

        // 思考一个问题：
        // 我想直到zhangsan他是哪个城市的，代码应该怎么写？
        System.out.println(u.username + "是"+u.addr.city+"城市的！");

        // u.addr.city 这行代码可否拆分呢？u.addr.city 节省变量。
        // 拆分成以下代码和以上效果完全相同，原理完全相同，不同的是以下代码多了两个变量。
        Address ad = u.addr;
        String zhuZhi = ad.city;

        System.out.println(zhuZhi);

        //-----------------------是否理解以下代码---------------------------
        int x = 100;
        // = 代表赋值运算，“赋值”中有一个“值”
        // x变量中的值是100. 将100复制一份给y
        // 表示：将x变量中保存的值100复制一份给y
        int y = x;

        //-----------------------是否理解以下代码---------------------------
        Address k = new Address(); // Address k = 0x1111;
        Address m = k; // 这里表示将k变量中保存的0x1111复制了一份传给了m变量。

    }
}

　　需要注意：

　　// int x = 100 ;  -- 在栈里直接保存 100

　　// = 代表赋值运算，“赋值” 中有个值；

　　//  X 变量中的值是100，将100 复制一份到 y

　　// int y= x;

　　//-----------------------

　　Address k = new Address(); // Address k = 0x1111; -- 这个是 堆中的对象的地址
　　Address m = k; // 这里表示将k变量中保存的0x1111复制了一份传给了m变量。

 

空指针异常（NullPointerException）

　　

/*
    空指针异常。（NullPointerException）

    关于垃圾回收器：GC
        在java语言中，垃圾回收器主要针对的是堆内存。
        当一个java对象没有任何引用指向该对象的时候，
        GC会考虑将该垃圾数据释放回收掉。
    
    出现空指针异常的前提条件是？
        "空引用"访问实例【对象相关】相关的数据时，都会出现空指针异常。
*/
public class NullPointerTest{
    public static void main(String[] args){
        // 创建客户对象
        Customer c = new Customer();
        // 访问这个客户的id
        System.out.println(c.id); // 0

        // 重新给id赋值
        c.id = 9521; // 终身代号
        System.out.println("客户的id是=" + c.id);

        c = null;
        // NullPointerException
        // 编译器没问题，因为编译器只检查语法，编译器发现c是Customer类型，
        // Customer类型中有id属性，所以可以：c.id。语法过了。
        // 但是运行的时候需要对象的存在，但是对象没了，尴尬了，就只能出现一个异常。
        System.out.println(c.id);
    }
}

class Customer{
    // 客户id
    int id; // 成员变量中的实例变量，应该先创建对象，然后通过“引用.”的方式访问。
}

 

方法调用参数传递

　　　　java中规定：参数传递的时候，和类型无关，不管是基本数据类型还是引用数据类型

　　　　　　　　　　统一都是将盒子中保存的那个“值”复制一份，传递下去。

　　　　java中只有一个规定：参数传递的时候，一定是将“盒子”中的东西复制一份传递过去。

　　　　　　　　　　　　　　内存地址也是值，也是盒子中保存的一个东西。

　　　

　　　

 

　　　　

ps  Java中没有指针，通过引用访问堆内存的数据