新手初学Java面向对象

面向对象【Java语言的核心机制，最重要的内容，Java语言的特色】
    * 面向过程和面向对象的区别
        - 面向过程：主要关注点是：实现的具体过程，因果关系【集成显卡的开发思路】
            * 优点：对于业务逻辑比较简单的程序，可以达到快速开发，前期投入成本较低。
            * 缺点：采用面向过程的方式开发很难解决非常复杂的业务逻辑，另外面向过程的
            方式导致软件元素之间的“耦合度”非常高，只要其中一环出问题，整个系统受到影响，
            导致最终的软件“扩展力”差。另外，由于没有独立体的概念，所以无法达到组件复用。
        - 面向对象：主要关注点是：主要关注对象【独立体】能完成哪些功能。【独立显卡的开发思路】
            * 优点：耦合度低，扩展力强。更容易解决现实世界当中更复杂的业务逻辑。组件复用性强。
           * 缺点：前期投入成本较高，需要进行独立体的抽取，大量的系统分析与设计。
                - C语言是纯面向过程的、C++半面向对象、Java纯面向对象
        - 现在出现的一些新的编程语言多数都是面向对象的。人在认识现实世界的时候以面向对象的方式。
        - 面向对象更符合人的思维方式。
    * 面向对象的三大特征【先背会】
        - 封装
        - 继承
        - 多态
        所有面向对象的编程语言都有这三大特征。
           采用面向对象的方式开发一个软件，生命周期当中：【整个生命周期中贯穿使用OO面向对象方式】
            * 面向对象的分析：OOA
            * 面向对象的设计：OOD
            * 面向对象的编程：OOP
    * 类和对象的概念
        * 什么是类？
            - 类在现实世界当中是不存在的，是一个模板，是一个概念。是人类大脑思考抽象的结果。
            - 类代表了一类事物。
            - 在现实世界当中，对象A与对象B之间具有共同特征，进行抽象总结出一个模板，这个模板被称为类。
       * 什么是对象？
            - 对象是实际存在的个体。现实世界当中实际存在。
               * 描述一下整个软件开发的过程：
            * 程序员先观察现实世界，从现实世界当中寻找对象
            * 寻找了N多个对象之后，发现所有的对象都有共同特征
            * 程序员在大脑中形成了一个模板【类】
            * Java程序员可以通过java代码来表述一个类
            * Java程序中有了类的定义
            * 然后通过类就可以创建对象
            * 有了对象之后，可以让对象直接协作起来形成一个系统。
                * 类--【实例化】->对象
        * 对象又被称为实例/instance
        * 对象--【抽象】-->类
        * 重点：
            类描述的是对象的共同特征。
            共同特征例如：身高特征
            这个身高特征在访问的时候，必须先创建对象，通过对象去访问这个特征。
            因为这个特征具体的某个对象上之后，值不同。有的对象身高1.80，有的
            对象身高2.80。
                * 一个类主要描述什么信息呢？
            一个类主要描述的是 状态 + 动作。
            状态信息：名字、身高、性别、年龄
            动作信息：吃、唱歌、跳舞、学习
            状态--> 一个类的属性
            动作--> 一个类的方法
               * 
            类{
                属性; //描述对象的状态信息
                方法; //描述对象的动作信息
            }
            注意：
                状态和动作当具体到某个对象上之后，发现最终的结果可能不一样。
                对象和对象之间有共同特征，但是具体到对象之后有数据的差异。
    * 类的定义【从这里开始编写代码】
        语法结构：
            [修饰符列表] class 类名{
                属性;
                方法;
            }
                学生类，描述所有学生对象的共同特征：
            学生对象有哪些状态信息：
                * 学号【int】
                * 名字【String】
                * 性别【boolean】
                * 年龄【int】【年龄是一个属性，年龄是一个数据，是数据就应该有数据类型】
                * 住址【String】
                .....
            学生对象有哪些动作信息：
                * 吃饭
                * 睡觉
                * 学习
                * 玩
                * 唱歌
                * 跳舞
                ....
                    重点：属性通常是采用一个变量的形式来完成定义的。
            int no;
            int age;
            String name;
            String address;
            boolean sex;
       * java语言中包括两种数据类型：
        - 基本数据类型
            byte
            short
            int
            long
            float
            double
            boolean
            char
        - 引用数据类型
            String.class SUN提供的
            System.class SUN提供的
           Student.class 程序员自定义的
            User.class 程序员自定义的
            Product.class 程序员自定义的
            Customer.class 程序员自定义的
            ......
                - java语言中所有的class都属于引用数据类型。

// 定义一个类，类名Student
// Student是一个类，代表了所有的学生对象，是一个学生的模板。
public class Student{    // 定义一个公开的类，起名Student
    // 属性【描述的是对象的状态信息】
    // 熟悉通常采用变量的方式来定义
    // 在类体当中，方法体之外定义的变量被称为“成员变量”
    // 成员变量没有赋值，系统赋默认值：一切箱0看齐。
    // 学号
    int no;
    // 姓名
    String name;
    // 性别
    boolean sex;
    // 年龄
    int age;
    // 住址
    String address;
    // 方法
    // 方法描述的是对象的动作信息
    // 当前例子就只描述属性了
}

// 学生类
// 学生类是一个模板
// 描述了所有学生的共同特征【状态+行为】
// 当前类只描述学生的状态信息【属性】
// Student是类，属于引用数据类型，这个类型名就是：Student
public class Student{
    // 类体-属性+方法
    // 属性【存储数据采用变量的形式】
    // 由于变量定义在类体当中，方法体之外，这种变量称为成员变量
    // 所有学生都有学好信息
    // 但是每一个学生的学号都是不同的
    // 所以要访问这个学号必须先创建对象，通过对象去访问学号信息
    // 学号信息不能直接通过“类”去访问，所以这种成员变量又被叫做：实例变量
    // 对象又被称为实例，实例变量又成为对象变量。【对象级别的变量】
    // 不创建对象，这个no变量的内存空间是不存在的，只有创建了对象，这个no变量内存空间才会创建
    int no;
    // 姓名
    String name;
    // 年龄
    int age;
    // 性别
    boolean sex;
    // 住址
    String addr;

}
// 成员变量没有手动赋值的话，系统赋默认值
// 默认值

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

public class OOTest01
{
    public static void main(String[] args){
        // int 是基本数据类型
        // i 是一个变量名
        // 10是一个int类型的字面值
        int i = 10;
        // 通过一个类可以实例化N个对象
        // 实例化对象的语法：new 类名();
        // new是java语言当中的一个运算符
        // new运算符的作用是创建对象，在JVM堆内存当中开辟新的内存空间
        // 方法区内存：在类加载的时候，class字节码片段被加载到该内存空间当中
        // 栈内存（局部变量）：方法代码片段执行的时候，会给该方法分配内存空间，在栈内存中压栈
        // 堆内存：new的对象在堆内存中存储
        // Student是一个应用数据类型
        // s 是一个变量名
        // new Student()是一个学生对象
        // s是一个局部变量【在栈内存中存储】
        // 什么是对象？new运算符在堆内存中开辟的内存空间称为对象
        // 什么是引用？引用是一个变量，只不过这个变量保存了另一个java对象的内存地址
        // java语言当中，程序员不能直接操作堆内存，java中没有指针，不像c语言
        // java语言当中，程序员只能通过“引用”去访问堆内存当中对象内部的示例变量
        Student s = new Student();
        // 访问实例变量的语法格式：
        // 读取数据：引用.变量名
        // 修改数据：引用.变量名 = 值
        
        s.no = 10;
        s.name = "jack";
        s.age = 20;
        s.sex = true;
        s.addr = "深圳";
        System.out.println("学号 = " + s.no);    // 10
        System.out.println("姓名 = " + s.name);    // jack
        System.out.println("年龄 = " + s.age);    // 20
        System.out.println("性别 = " + s.sex);    // true
        System.out.println("地址 = " + s.addr);    // 深圳
        // 编译报错，no这个实例变量不能直接采用”类名“的方式访问
        // 因为no是实例变量，对象级别的变量，变量存储在java对象的内部，必须先有对象
        // 通过对象才能访问no这个实例变量，不能直接通过"类名"访问
        // System.out.println(Student.no);
        // 在通过类实例化一个全新的对象
        // stu是一个引用类型
        // stu同时也是一个局部变量
        // Student是变量的数据类型
        Student stu = new Student();
        System.out.println("学号 = " + stu.no);        // 0
        System.out.println("姓名 = " + stu.name);    // null
        System.out.println("年龄 = " + stu.age);    // false
        System.out.println("性别 = " + stu.sex);    // 0
        System.out.println("地址 = " + stu.addr);    // null
    }
}

// 用户类
public class User{
    // 属性【以下都是成员变量之实例变量】
    // 用户编号
    // int 是一种基本数据类型：整数型
    // no是一个实例变量
    int no;
    // 用户名
    // String 是一种引用数据类型：代表字符串
    // name是一个实例变量
    // name是一个引用
    String name;
    // 家庭住址
    // Adddress是一种引用数据类型：代表家庭住址
    // addr是一个实例变量
    // addr是一个引用
    Address addr;
}
// ----------------------------------------------------------------------
// 家庭住址类
public class Address{
    // 属性成员变量之实例变量】
    // 城市
    // String是一种引用数据类型，city是一个变量名，属于实例变量
    // oity是一个引用：保存内存地址的一个变量，该变量保存内存地址指向了堆内存当中的对象
    String city;
    // 街道
    String street;
    // 邮编
    String zipcode;
}
// ----------------------------------------------------------------------
// 测试类
public class OOTest02{
    public static void main(String[] args){
        // 创建User对象
        // u是局部变量
        // u是一个应用
        // u保存内存地址指向堆内存的User对象
        User u = new User();
        // 输出User对象内部实例变量的值
        System.out.println(u.no);    // 0
        System.out.println(u.name);    // null
        System.out.println(u.addr);    //  null
        // 修改User对象内部实例变量的值
        u.no = 110;
        u.name = "jack";    // "jack" 是一个java对象，属于String对象
        u.addr = new Address();
        // 在main方法当中目前只能看到一个引用“u”
        // 一切都是只能通过u来进行访问
        System.out.println(u.name + "居住在那个城市:" + u.addr.oity);
        System.out.println(u.name + "居住在那个街道:" + u.addr.street);
        System.out.println(u.name + "居住在那个邮编:" + u.addr.zipcode);
        u.addr.oity = "深圳";
        u.addr.street = "福田";
        u.addr.zipcode = "516600";
        System.out.println(u.name + "居住在那个城市:" + u.addr.oity);
        System.out.println(u.name + "居住在那个街道:" + u.addr.street);
        System.out.println(u.name + "居住在那个邮编:" + u.addr.zipcode);


    }
}

public class OOTest03{
    public static void main(String[] args){
        // u是引用
        // u是局部变量
        User u = new User();
        // 上一个版本中编写的
        // u.addr = new Address();
        // a是引用
        // a是局部变量
        Address a = new Address();
        u.addr = a;
        
        System.out.println(u.addr.city); // null
        a.city = "天津";
        System.out.println(u.addr.city);  // 天津
        u.addr.city = "深圳";
        System.out.println(u.addr.city);    // 深圳
    }
}

// 丈夫类
public class Husband{
    // 姓名
    String name;
    // 丈夫对象当中含有妻子引用
    Wife w;
}
// -----------------------------------------------------------------

// 妻子类
public class Wife{
    // 姓名
    String name;
    // 妻子对象当中含有丈夫引用
    Husband h;
}
// -------------------------------------------------------------------
public class OOTest04{
    public static void main(String[] args){
        // 创建一个丈夫对象
        Husband huangXiaoMing =  new Husband();
        huangXiaoMing.name = "黄晓明";
        // 创建一个妻子对象
        Wife baby = new Wife();
        baby.name = "baby";
        // 结婚【能通过丈夫找到妻子，通过妻子也可以找到丈夫】
        huangXiaoMing.w = baby;
        baby.h = huangXiaoMing;
        // 得到以上“黄晓明”的妻子的名字
        System.out.println(huangXiaoMing.name + "的妻子名字叫：" + baby.name);
        System.out.println(huangXiaoMing.name + "的妻子名字叫：" + huangXiaoMing.w.name);
    }
}

// 顾客类
public class Customer
{
    // id
    int id;
}
// ------------------------------------------------------------------------
// 测试程序
public class OOTest05
{
    public static void main(String[] args){
        Customer c = new Customer();
        System.out.println(c.id); // 0
        c = null;
        // 以下程序编译可以通过，因为符合语法
        // 运行出现空指针异常
        // 空应用访问“实例”相关的数据一定会出现空指针异常
        // java.lang.NullPointerException
        System.out.println(c.id);
    }
}

// “实例”相关的数据表示：这个数据访问的时候必须有对象的参与，这种数据就是实例相关的数据

public class Product{
    // 编号 【通常是一个数字，而且该数字通常是整数型的】
    // productNo 是基本数据类型
    // 实例变量
    int productNo;
    // 单价 【通常是一个数字，但是数字可能带有小数，所以采用浮点型数据double表示】
    // price 是基本数据类型
    // 实例变量
    double price;
// ----------------------------------------------------------------------

public class ProductTest{    // 商品测试类
    // 程序入口
    public static void main(String[] args){
        // 创建对象，商品对象
        // iphone7 局部变量
        // iphone7 应用
        // iphone7 变量中保存内存地址的指向堆内存当中的商品对象
        Product    iphone7 = new Product();
        // 访问实例变量的语法：引用.变量
        // 读取：引用.变量名
        System.out.println("商品的编号：" + iphone7.productNo);
        System.out.println("商品的单价：" + iphone7.price);
        // 修改：引用.变量名 = 值;
        iphone7.productNo = 111;
        iphone7.price = 68000;
        System.out.println("商品的编号：" + iphone7.productNo);
        System.out.println("商品的单价：" + iphone7.price);

    }
}

// 人类
public class Ren{
    // 身份证号
    String id;
    // 名字
    String name;
    // 性别
    boolean sex;
    // 年龄
    int age;
}
// -------------------------------------------------------------------------

public class BieShu{
    // 面积
    double mianJi;
    // 主人【人类】
    // 变量/应引用
    // 变量怎么声明：数据类型 变量名;
    // 关联关系： A has a B 关系【A对象中含有B对象的引用】
    // BieShu对象含有Ren对象的引用
    Ren zhuRen;
}

// ----------------------------------------------------------------------
public class Test{
    public static void main(String[] args){
        // 思路：先创造人物对象，再创造别墅对象，让别墅有主人
        Ren zhangsan = new Ren();    // 初始化
        // 不采用系统默认值
        // 手动赋值
        zhangsan.id = "45682110";
        zhangsan.name = "张三";
        zhangsan.sex = true;
        zhangsan.age = 100;
        // 创建别墅对象
        BieShu fangzi = new BieShu();
        fangzi.mianJi = 150.0;
        fangzi.zhuRen = zhangsan;
        // 想知道房子主人的名字是什么？
        System.out.println(fangzi.zhuRen.name);
        // 房子换主人
        // 创建一个新的主人对象
        Ren lisi = new Ren();
        lisi.name = "李四";
        // 换主人
        fangzi.zhuRen = lisi;
        System.out.println(fangzi.zhuRen.name);
    }
}

// 学生类
class Student{
    String name;
    int no;
    // 笔记本
    Notebook book;
}

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

// 笔记本类
class Notebook{
    // 品牌
    String brand;
    // 型号
    String model;
    // 颜色
    String color;
}

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


// 测试类
public class OOTest06{
    public static void main(String[] args){
        // 创建笔记本对象
        Notebook BiJiBen = new Notebook();
        // 手动赋值
        BiJiBen.brand = "华为";
        BiJiBen.model = "KX100";
        BiJiBen.color = "黑色";

        // 创建学生对象
        Student s = new Student();
        // 手动赋值
        s.no = 111;
        s.name = "jack";
        s.book = BiJiBen;
        System.out.println(s.name);
        System.out.println(s.no);
        System.out.println(s.book.brand);
        
        // 让这个学生和笔记本对象产生关系【通过学生能找到他的笔记本】
        System.out.println("学号：" + s.no + " 名字叫 " + s.name + " 的电脑品牌是：" + s.book.brand);
        System.out.println("学号：" + s.no + " 名字叫 " + s.name + " 的电脑品牌是：" + s.book.model);
        System.out.println("学号：" + s.no + " 名字叫 " + s.name + " 的电脑品牌是：" + s.book.color);

        // 修改品牌
        s.book.brand = "苹果";
        System.out.println("学号：" + s.no + " 名字叫 " + s.name + " 的电脑品牌是：" + s.book.brand);
    }
}