04-第四章 面向对象

day13课堂笔记

1、面向过程和面向对象有什么区别？

从语言方面出发：
对于C语言来说，是完全面向过程的。
对于C++语言来说，是一半面向过程，一半是面向对象。（C++是半面向对象的）
对于Java语言来说，是完全面向对象的。

什么是面向过程的开发方式？
面向过程的开发方式主要的特点是：
注重步骤，注重的是实现这个功能的步骤。
第一步干什么
第二步干什么
....
另外面向过程也注重实现功能的因果关系。
因为A所有B
因为B所以C
因为C所以D
.....
面向过程中没有对象的概念。只是实现这个功能的步骤以及因果关系。

面向过程有什么缺点？（耦合度高，扩展力差。）
面向过程最主要是每一步与每一步的因果关系，其中A步骤因果关系到B
步骤，A和B联合起来形成一个子模块，子模块和子模块之间又因为因果
关系结合在一起，假设其中任何一个因果关系出现问题（错误），此时
整个系统的运转都会出现问题。（代码和代码之间的耦合度太高，扩展力
太差。）
螺栓螺母拧在一起：耦合度高吗？
这是耦合度低的，因为螺栓螺母可以再拧开。（它们之间是有接口的。）
螺栓螺母拧在一起之后，再用焊条焊接在一起，耦合度高吗？
这个耦合度就很高了。耦合度就是黏连程度。
往往耦合度高的扩展力就差。

耦合度高导致扩展力差。（集成显卡：计算机显卡不是独立的，是集成到主板上的）
耦合度低导致扩展力强。（灯泡和灯口关系，螺栓螺母关系）

采用面向过程的方式开发一台计算机会是怎样？
这台计算机将没有任何一个部件，所有的都是融合在一起的。
你的这台计算机是一个实心儿的，没有部件的。一体机。
假设这台一体机的任何一个“部位”出问题，整个计算机就不能用了，
必须扔掉了。（没有对象的概念。）

采用面向对象的方式开发一台计算机会是怎样？
内存条是一个对象
主板是一个对象
CPU是一个对象
硬盘是一个对象
然后这些对象组装在一起，形成一台计算机。
假设其中CPU坏了，我们可以将CPU拆下来，换一个新的。

面向过程有什么优点？（快速开发）
对于小型项目（功能），采用面向过程的方式进行开发，效率较高。
不需要前期进行对象的提取，模型的建立，采用面向过程
方式可以直接开始干活。一上来直接写代码，编写因果关系。
从而实现功能。

什么是面向对象的开发方式？
采用面向对象的方式进行开发，更符合人类的思维方式。（面向对象成为主流的原因）
人类就是以“对象”的方式去认识世界的。
所以面向对象更容易让我们接受。

面向对象就是将现实世界分割成不同的单元，然后每一个单元
都实现成对象，然后给一个环境驱动一下，让各个对象之间协
作起来形成一个系统。

对象“张三”
对象“香烟”
对象“打火机”
对象“吸烟的场所”
然后将以上的4个对象组合在一起，就可以模拟一个人的抽烟场景。
其中“张三”对象可以更换为“李四”
其中“香烟”也可以更换品牌。
其中“打火机”也可以更换。
其中“吸烟的场所”也可以更换。

采用面向对象的方式进行开发：
耦合度低，扩展力强。

找一个合适的案例。说明一下面向对象和面向过程的区别？
蛋炒饭：
鸡蛋和米饭完全混合在一起。没有独立对象的概念。
假设客户提出新需求：我只想吃蛋炒饭中的米饭，怎么办？
客户提出需求，软件开发者必须满足这个需求，于是
开始扩展，这个软件的扩展是一场噩梦。（很难扩展，耦合度太高了。）

盖饭：
老板，来一份：鱼香肉丝盖饭
鱼香肉丝是一道菜，可以看成一个独立的对象。
米饭可以看成一个独立的对象。
两个对象准备好之后，只要有一个动作，叫做：“盖”
这样两个对象就组合在一起了。

假设客户提出新需求：我不想吃鱼香肉丝盖饭,想吃西红柿鸡蛋盖饭。
这个扩展就很轻松了。直接把“鱼香肉丝”对象换成“西红柿鸡蛋”对象。

目前先听一下，需要三四年的时候才能彻底领悟面向对象。

面向过程主要关注的是：实现步骤以及整个过程。
面向对象主要关注的是：对象A，对象B，对象C，然后对象ABC组合，或者CBA组合.....

2、当我们采用面向对象的方式贯穿整个系统的话，涉及到三个术语：
OOA：面向对象分析
OOD：面向对象设计
OOP：面向对象编程
整个软件开发的过程，都是采用OO进行贯穿的。

实现一个软件的过程：
分析(A) --> 设计(D) --> 编程(P)

在软件公司当中，一般同事与同事之间聊天，有的时候会突然说出来一个英语单词。
这种情况是很常见的。所以一些术语还是要知道的，不然会闹出笑话。

leader 领导/经理/组长
team 团队
PM 项目经理（整个项目的监管人）Project Manager

3、面向对象包括三大特征
封装
继承
多态

任何一个面向对象的编程语言都包括这三个特征
例如：
python也有封装 继承 多态。
java也有封装 继承 多态。

注意：java只是面向对象编程语言中的一种。
除了java之外，还有其它很多很多的编程语言也是面向对象的。

以上三个特征的名字先背会，后面一个一个进行学习。

4、类和对象的概念

面向对象当中最主要“一词”是：对象。

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

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

明星是一个类

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

宋小宝就是一个对象
姚明就是一个对象
刘德华就是一个对象
....

宋小宝、姚明、刘德华这3个对象都属于“明星”这个类。

在java语言中，要想得到“对象”，必须先定义“类”，“对象”是通过“类”
这个模板创造出来的。
类就是一个模板：类中描述的是所有对象的“共同特征信息”
对象就是通过类创建出的个体。

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

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

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

潘长江对象：
名字：潘长江
身高：165cm

打篮球：非专业的，自己玩儿呢，无所谓了
学习：考试80分

姚明对象：
名字：姚明
身高：240cm
打篮球：NBA专业球员，打篮球非常棒
学习：考试100分

共同特征包括哪些？
名字、身高都属于名词（状态特征）
打篮球、学习都属于动词（动作特征）

类 = 属性 + 方法
属性来源于：状态
方法来源于：动作

public class 明星类{
//属性-->状态，多见于名词
名字属性;
身高属性;

//方法-->动作，多见于动词
打篮球方法(){

}
学习方法(){

}
}

陈赓同学、何伟彬同学，他们俩有没有共同特征呢？
有共同特征，就可以抽象一个类模板出来。

可以定义一个学生类（Student）
public class Student {
// 属性
// 姓名
// 性别
// 身高

// 方法
public .... sing(){

}
public .... dance(){

}
public .... study(){

}
....
}

5、思考：“java软件工程师”在开发中起到的一个作用是什么？

我们为什么要做软件开发？
说的大一些是为了人民服务。解决现实生活当中的问题。

软件开发既然是为了解决现实世界当中的问题，那么首先
java软件必须能够模拟现实世界。

其实软件是一个虚拟的世界。
这个虚拟的世界需要和现实世界一一对应，这才叫模拟。

6、类的定义
6.1、怎么定义一个类，语法格式是什么？
[修饰符列表] class 类名 {
//类体 = 属性 + 方法
// 属性在代码上以“变量”的形式存在（描述状态）
// 方法描述动作/行为
}

注意：修饰符列表可以省略。

6.2、为什么属性是“以”变量的形式存在的？
假设我们要描述一个学生：
学生包括哪些属性：
学号: 110
姓名："张三"
性别：'男' (true/false)
住址："深圳宝安区"
答案：是因为属性对应的是“数据”，数据在程序中只能放到变量中。
结论：属性其实就是变量。

变量的分类还记得吗？
变量根据出现位置进行划分：
方法体当中声明的变量：局部变量。
方法体外声明的变量：成员变量。（这里的成员变量就是“属性”）

6.3、请大家观察“学生对象1”和“学生对象2”的共同特征，然后再利用java语言
将该“学生类”表述/表达出来。（这里只表达属性，不表达方法.）

7、关于编译的过程
按说应该先编译XueSheng.java，然后再编译XueShengTest.java
但是对于编译器来说，编译XueShengTest.java文件的时候，会自动
找XueSheng.class，如果没有，会自动编译XueSheng.java文件，生成
XueSheng.class文件。
第一种方式：
javac XueSheng.java
javac XueShengTest.java
第二种方式：
javac XueShengTest.java
第三种方式：
javac *.java

8、在语法级别上是怎么完成对象创建的呢？
类名 变量名 = new 类名();
这样就完成了对象的创建。

9、什么是实例变量？
对象又被称为实例。
实例变量实际上就是：对象级别的变量。
public class 明星类{
double height;
}
身高这个属性所有的明星对象都有，但是每一个对象都有“自己的身高值”。
假设创建10个明星对象，height变量应该有10份。
所以这种变量被称为对象级别的变量。属于实例变量。

实例变量在访问的时候，是不是必须先创建对象？

10、对象和引用的区别？
对象是通过new出来的，在堆内存中存储。
引用是：但凡是变量，并且该变量中保存了内存地址指向了堆内存当中的对象的。

 

/*
    对象的创建和使用。
*/
public class XueShengTest{
    public static void main(String[] args){

        int i = 100;
        System.out.println("i = " + i);
        
        // 在这里可以访问XueSheng类吗？
        // 当然可以。
        /*
            创建对象的语法是什么？
                目前死记硬背，先记住。后面你就理解了。
                    new 类名();
            类是模板，通过一个类，是可以创建N多个对象的。
            new是一个运算符。专门负责对象的创建。

            XueSheng s1 = new XueSheng();
            和
            int i = 100;
            解释一下：
                i是变量名
                int是变量的数据类型
                100是具体的数据。
                
                s1是变量名（s1不能叫做对象。s1只是一个变量名字。）
                XueSheng是变量s1的数据类型（引用数据类型）
                new XueSheng() 这是一个对象。（学生类创建出来的学生对象。）
            
            数据类型包括两种：
                基本数据类型：byte short int long float double boolean char
                引用数据类型：String、XueSheng.....

            java中所有的“类”都属于引用数据类型。

        */
        XueSheng s1 = new XueSheng(); // 和 int i = 10;一个道理。

        // 再通过该类创建一个全新的对象
        XueSheng s2 = new XueSheng();

        // 再创建一个呢？
        XueSheng xsh = new XueSheng();

        // 以上的这个程序就相当于通过XueSheng类实例化了3个XueSheng对象。
        // 创建对象的个数没有限制，可以随意。只要有模板类就行。
        // 3个对象都属于学生类型。

    }
}

/*
1、观察学生对象的共同特征（只观察属性）
    有哪些共同特征：
        学号：采用int类型
        姓名：采用String类型
        年龄：采用int类型
        性别：采用char或者boolean类型
        住址：采用String类型

        注意：属性是成员变量。
        
2、以上是分析总结的结果，可以开始写代码了：
    定义XueSheng类，编写成员变量作为属性。

3、变量有一个特点：
    必须先声明，再赋值，才能访问。
    成员变量可以不手动赋值？？？？？？？？？？

XueSheng既是一个类名，同时又是一个“类型名”，属于引用数据类型。
*/
public class XueSheng{ // 这个程序编译之后，会生成XueSheng.class字节码文件。

    // 属性

    // 学号（成员变量）
    int xueHao;

    // 姓名
    String xingMing;

    // 年龄
    int nianLing;

    // 性别
    boolean xingBie;

    // 住址
    String zhuZhi;

}

 

 

/*
学生类
    学号：int
    姓名：String
    年龄：int
    性别：boolean
    住址：String

变量必须先声明，再赋值才能访问。

注意：对于成员变量来说，没有手动赋值时，系统默认赋值。
赋的值都是默认值，那么默认值是什么？

类型                默认值
---------------------
byte                0
short                0
int                0
long                0L
float                0.0F
double            0.0
boolean            false
char                \u0000
引用数据类型    null

null是一个java关键字，全部小写，表示空。是引用类型的默认值。

分析：对于成员变量来说，是不是应该一个对象有一份。
    李四有李四的学号
    张三有张三的学号
    李四和张三的学号不一样。所以应该有两块不同的内存空间。

*/
public class Student{

    // 属性（描述状态），在java程序中以“成员变量”的形式存在。

    // 学号
    // 一个对象一份。
    int no; // 这种成员变量又被称为“实例变量”。

    // 姓名
    String name;

    // 年龄
    int age;

    // 性别
    boolean sex;

    // 住址
    String addr;

}

 

/*
    对象的创建和使用。
*/
public class StudentTest{

    public static void main(String[] args){

        //局部变量
        //错误: 可能尚未初始化变量k
        /*
        int k;
        System.out.println(k);
        */

        //访问学生姓名可以直接通过类名吗？
        // 学生姓名是一个实例变量。实例变量是对象级别的变量。
        // 是不是应该先有对象才能说姓名的事儿。
        // 不能通过“类名”来直接访问“实例变量”。
        //System.out.println(Student.name);
        
        // i属于局部变量吗？当然是。
        // 局部变量存储在栈内存当中。（栈主要存储局部变量。）
        //int i = 100;

        // 创建学生对象1
        // s1属于局部变量吗？当然是。
        // s1这个局部变量叫做引用
        Student s1 = new Student();
        // 怎么访问实例变量？
        // 语法：引用.实例变量名
        System.out.println(s1.no);
        System.out.println(s1.name);
        System.out.println(s1.age);
        System.out.println(s1.sex);
        System.out.println(s1.addr);

        System.out.println("-----------------------------");


        // 创建学生对象2
        // s2也是局部变量。
        // s2也叫做引用。
        Student s2 = new Student();
        System.out.println(s2.no);
        System.out.println(s2.name);
        System.out.println(s2.age);
        System.out.println(s2.sex);
        System.out.println(s2.addr);

        // 程序执行到此处我可以修改s1这个学生的学号吗？
        // 通过“=”赋值的方式将内存中实例变量的值修改一下。
        s1.no = 110;
        s1.name = "张三";
        s1.age = 20;
        s1.sex = true;
        s1.addr = "深圳宝安区";

        System.out.println("学号=" + s1.no);
        System.out.println("姓名=" + s1.name);
        System.out.println("年龄=" + s1.age);
        System.out.println("性别=" + s1.sex);
        System.out.println("住址=" + s1.addr);

        // 再次赋值
        s1.addr = "北京大兴区";
        System.out.println("住址：" + s1.addr);

    }

    public static void method(){
        // i s1 s2都是main方法中的局部变量，在这里是无法访问的。
        /*
        System.out.println(i);
        System.out.println(s1);
        System.out.println(s2);
        */
    }
}

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

/*
class 人类{
    // 成员变量，实例变量，对象级别变量，先造对象才能访问。
    double 身高;
}
*/

// byte short int long float double boolean char :这些默认值偏向0，false也是0
// 引用类型：null

// 第一步：类加载
// 第二步：调用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 学生{
    int 学号;
    String 姓名;

    // 入口
    public static void main(String[] args){
        学生 张三 = new 学生();
        System.out.println(张三.学号); // 0
        System.out.println(张三.姓名); // null

        张三.学号 = 1111;
        张三.姓名 = "张三";
        System.out.println(张三.学号);
        System.out.println(张三.姓名);
    }
}

// 和刚才的程序一样，只不过标识符采用了中文。
// 标识符可以有中文。

public class 学生测试{
    // 程序入口
    /*
    public static void main(String[] args){
        学生 张三 = new 学生();
        System.out.println(张三.学号); // 0
        System.out.println(张三.姓名); // null

        张三.学号 = 1111;
        张三.姓名 = "张三";
        System.out.println(张三.学号);
        System.out.println(张三.姓名);
    }
    */
}

// 把这个内存图画出来。一定要按照程序的执行顺序一步一步画。
public class T{
    A o1; // 成员变量中的实例变量。必须先创建对象，通过“引用”来访问。

    public static void main(String[] args){
        D d = new D();
        C c = new C();
        B b = new B();
        A a = new A();
        T t = new T();

        //这里不写代码会出现NullPointerException异常。（空指针异常。）
        c.o4 = d;
        b.o3 = c;
        a.o2 = b;
        t.o1 = a;

        // 编写代码通过t来访问d中的i
        //System.out.println(T.a); //错误的。
        System.out.println(t.o1.o2.o3.o4.i);
    }
}
class A{
    B o2;
}
class B{
    C o3;
}
class C{
    D o4;
}
class D{
    int i;
}

 

 

 

day14课堂笔记

1、画内存图注意事项：

第一：大家在内存图上不要体现出代码。内存上应该主要体现“数据”。

第二：大家画图的时候，图上的图形应该有先后顺序，先画什么，再
画什么，必须是有顺序的，而不是想起来这个画这个，想起来那个画那个。
程序代码是有执行顺序的，程序执行到哪里你就画哪里就行了。

2、为什么要画内存图（非常重要）？
第一：有了内存图，程序不运行，我也知道结果。（可以推算出结果）
第二：有了内存图，有助于你调试程序。
画内存图是对Java运行机制的一种理解。不知道运行机制，以后复杂的
程序出现错误之后你是不会调试的，调不明白。

3、程序在什么情况下会出现空指针异常呢？
空引用 访问 "对象相关"的数据时，会出现空指针异常。
垃圾回收器主要针对堆内存。

 

/*
    空指针异常。（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; // 成员变量中的实例变量，应该先创建对象，然后通过“引用.”的方式访问。
}

 

 

 

4、方法在调用的时候参数是如何传递的？
实际上，在java语言中，方法调用时参数传递，和类型无关，都是将变量中保存
的那个“值”传过去，这个“值”可能是一个数字100，也可能是一个java对象的内存
地址：0x1234
记住这句话：不管是哪一种数据类型的传递，都是将“变量中保存的那个值复制一份传递过去。”

 

// 分析程序的输出结果。
// java中规定：参数传递的时候，和类型无关，不管是基本数据类型还是引用数据类型
// 统一都是将盒子中保存的那个“值”复制一份，传递下去。

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

// 内存地址也是值，也是盒子中保存的一个东西。
public class Test1{
    public static void main(String[] args){

        int x = 100;
        int y = x; // x赋值给y，是怎么传递的？将x变量中保存的100这个值复制一份传给y

        // 局部变量，域是main
        int i = 10;
        // 将i变量中保存的10复制一份，传给add方法。
        add(i); 
        System.out.println("main ---> " + i); //10
    }

    /*
    public static void add(int i){ // i是局部变量，域是add
        i++;
        System.out.println("add ----> " + i); //11
    }
    */

    public static void add(int k){ 
        k++;
        System.out.println("add ----> " + k); 
    }
}

 

/*
    java中关于方法调用时参数传递实际上只有一个规则：
        不管你是基本数据类型，还是引用数据类型，实际上在传递的时候都是
        将变量中保存的那个“值”复制一份，传过去。

        int x = 1;
        int y = x; 把x中保存1复制一份传给y
        x和y都是两个局部变量。

        Person p1 = 0x1234;
        Person p2 = p1; 把p1中保存的0x1234复制一份传给p2
        p1和p2都是两个局部变量。

        你和你媳妇，都有你家大门上的钥匙，钥匙是两把。
        但是都可以打开你家的大门。

*/

public class Test2{
    public static void main(String[] args){
        Person p = new Person();
        p.age = 10;
        add(p);
        System.out.println("main--->" + p.age); //11
    }
    // 方法的参数可以是基本数据类型，也可以是引用数据类型，只要是合法的数据类型就行。
    public static void add(Person p){ // p是add方法的局部变量。
        p.age++;
        System.out.println("add--->" + p.age); //11
    }
}

class Person{
    // 年龄属性，成员变量中的实例变量。
    int age;
}

 

 

5、构造方法。
5.1、当一个类中没有提供任何构造方法，系统默认提供一个无参数的构造方法。
这个无参数的构造方法叫做缺省构造器。

5.2、当一个类中手动的提供了构造方法，那么系统将不再默认提供无参数构造方法。
建议将无参数构造方法手动的写出来，这样一定不会出问题。

5.3、无参数构造方法和有参数的构造方法都可以调用。
Student x = new Student();
Student y = new Student(123);

5.4、构造方法支持方法重载吗？
构造方法是支持方法重载的。
在一个类当中构造方法可以有多个。
并且所有的构造方法名字都是一样的。

方法重载特点：
在同一个类中，方法名相同，参数列表不同。

5.5、对于实例变量来说，只要你在构造方法中没有手动给它赋值，
统一都会默认赋值。默认赋系统值。

构造方法需要掌握的知识点：
1.构造方法有什么作用？
2.构造方法怎么定义，语法是什么？
3.构造方法怎么调用，使用哪个运算符？
4.什么是缺省构造器？
5.怎么防止缺省构造器丢失？
6.实例变量在类加载是初始化吗？实例变量在什么时候初始化？

 

/*
    构造方法
        1、什么是构造方法，有什么用？
            构造方法是一个比较特殊的方法，通过构造方法可以完成对象的创建，
            以及实例变量的初始化。换句话说：构造方法是用来创建对象，并且
            同时给对象的属性赋值。（注意：实例变量没有手动赋值的时候，系统
            会赋默认值。）

        2、重点（需要记忆）：当一个类没有提供任何构造方法，系统会默认提供
        一个无参数的构造方法。（而这个构造方法被称为缺省构造器。）

        3、调用构造方法怎么调用呢？
            使用哪个运算符呢？
                使用new运算符来调用构造方法。
                语法格式：
                    new 构造方法名(实际参数列表);
        
        4、构造方法的语法结构是？

            [修饰符列表] 构造方法名(形式参数列表){
                构造方法体;
                通常在构造方法体当中给属性赋值，完成属性的初始化。
            }

            注意：
                第一：修饰符列表目前统一写：public。千万不要写public static。

                第二：构造方法名和类名必须一致。

                第三：构造方法不需要指定返回值类型，也不能写void，写上void
                表示普通方法，就不是构造方法了。

            普通方法的语法结构是？
                [修饰符列表] 返回值类型 方法名(形式参数列表){
                    方法体;
                }
*/
public class ConstructorTest01{
    public static void main(String[] args){

        // 调用Student类的无参数构造方法
        new Student();

        // 调用普通方法
        ConstructorTest01.doSome();
        doSome();

        // 创建Student类型的对象
        Student s1 = new Student();

        // 输出“引用”
        //只要输出结果不是null，说明这个对象一定是创建完成了。
        // 此处的输出结果大家目前是看不懂的，后期再说。
        System.out.println(s1); //Student@54bedef2

        // 这是调用另一个有参数的构造方法。
        Student s3 = new Student(100);
        System.out.println(s3); //Student@5caf905d
    }

    public static void doSome(){
        System.out.println("do some!!!!");
    }
}

 

/*
    1、构造方法对应的英语单词：Constructor【构造器】
    2、构造方法作用：
        创建对象，并且创建对象的过程中给属性赋值（初始化。）
*/
public class ConstructorTest02{
    public static void main(String[] args){

        User u = new User();

        System.out.println(u.id); //111
        System.out.println(u.name); //lisi
        System.out.println(u.age); //30

        User u2 = new User(1111111);
        System.out.println(u2.id); //0
        System.out.println(u2.name); // null
        System.out.println(u2.age); // 0
    }
}

public class ConstructorTest03{
    public static void main(String[] args){
        //调用不同的构造方法创建对象
        Vip v1 = new Vip();
        System.out.println(v1.no); //0
        System.out.println(v1.name); // null
        System.out.println(v1.birth); // null
        System.out.println(v1.sex); // false

        Vip v2 = new Vip(11111L, "大灰狼");
        System.out.println(v2.no); // 11111L
        System.out.println(v2.name); // "大灰狼"
        System.out.println(v2.birth); // null
        System.out.println(v2.sex); // false

        Vip v3 = new Vip(22222L, "小绵羊", "2000-10-10");
        System.out.println(v3.no); // 22222L
        System.out.println(v3.name); //"小绵羊"
        System.out.println(v3.birth); // "2000-10-10"
        System.out.println(v3.sex); // false

        Vip v4 = new Vip(33333L, "钢铁侠", "1980-10-11", true);
        System.out.println(v4.no); // 33333L
        System.out.println(v4.name); //"钢铁侠"
        System.out.println(v4.birth); //"1980-10-11"
        System.out.println(v4.sex); //true
    }

}

public class Student{

    // 学号
    int no;

    // 姓名
    String name;

    // 年龄
    int age;

    // 当前的Student这个类当中并没有定义任何构造方法。
    // 但是系统实际上会自动给Student类提供一个无参数的构造方法。
    // 将无参数的构造方法（缺省构造器）写出来
    public Student(){
        System.out.println("无参数的构造方法执行了！");
    }

    // 定义一个有参数的构造方法
    public Student(int i){
    
    }

    /*
        编译器检测到该方法名“Studen”，发现这个名字和类名不一致，
        编译器会认为该方法是一个普通方法，普通方法应该有返回值
        但是没有写返回值类型，所以报错了。
         错误: 方法声明无效; 需要返回类型
    */
    /*
    public Studen(String name){
    
    }
    */

    // 第一种修改方式
    //public void Studen(String name){}

    // 第二种修改方式
    public Student(String name){
    
    }
}

/*
    1、id,name,age都有默认值对吗？
        对。

    2、id的默认值是：0 
    name的默认值是：null
    age的默认值是：0
    
    3、思考：实例变量没有手动赋值的时候，实际上系统会默认赋值，
    那么这个默认赋值操作是在什么时间进行的？
        是在类加载的时候给这些实例变量赋值吗？
            不是，实例变量是在构造方法执行的过程中完成初始化的，完成赋值的。
*/
public class User{
    // 3个属性，3个实例变量【对象变量】
    // 用户id
    int id; //System.out.println(User.id);错误的。需要先new对象，只有对象有了才能谈id

    // 用户名
    String name;

    // 年龄
    int age;

    // 手动定义有参数的构造方法，无参数构造方法将消失。
    public User(int a){

    }

    public User(){
        //这里实际上有三行代码你看不见。
        // 无参数构造方法体当中虽然什么代码都没写，
        // 但是实际上是在这个方法体里面进行的实例变量默认值初始化
        /*
        id = 0;
        name = null;
        age = 0;
        */
        
        // 这就表示不再采用系统默认值，手动赋值了。
        id = 111;
        name = "lisi";
        age = 30;

    }
}

public class Vip{

    // 会员号
    long no;

    // 会员姓名
    String name;

    // 生日
    String birth;

    // 性别
    boolean sex;

    //无参数构造方法
    public Vip(){

    }

    //有参数构造方法
    public Vip(long huiYuanHao, String xingMing){
        // 给实例变量赋值【初始化实例变量，初始化属性】
        no = huiYuanHao;
        name = xingMing;
        // 实际上这里还有两行代码（没有手动赋值，系统都会默认赋值。）
        //birth = null;
        //sex = false;
    }

    //有参数构造方法
    public Vip(long huiYuanHao,String xingMing, String shengRi){
        no = huiYuanHao;
        name = xingMing;
        birth = shengRi;
        // 实际上这里有一行默认的代码
        //sex = false;
    }

    //有参数的构造方法
    public Vip(long huiYuanHao,String xingMing,String shengRi,boolean xingBie){
        no = huiYuanHao;
        name = xingMing;
        birth = shengRi;
        sex = xingBie;
    }
}

 

// 住址类
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变量。

    }
}

 

 

6、封装

6.1、面向对象的三大特征：
封装
继承
多态

有了封装，才有继承，有了继承，才能说多态。

6.2、面向对象的首要特征：封装 。什么是封装？有什么用？
现实生活中有很多现实的例子都是封装的，例如：
手机，电视机，笔记本电脑，照相机，这些都是外部有一个坚硬的壳儿。
封装起来，保护内部的部件。保证内部的部件是安全的。另外封装了之后，
对于我们使用者来说，我们是看不见内部的复杂结构的，我们也不需要关心
内部有多么复杂，我们只需要操作外部壳儿上的几个按钮就可以完成操作。

那么封装，你觉得有什么用呢？
封装的作用有两个：
第一个作用：保证内部结构的安全。
第二个作用：屏蔽复杂，暴露简单。

在代码级别上，封装有什么用？
一个类体当中的数据，假设封装之后，对于代码的调用人员来说，
不需要关心代码的复杂实现，只需要通过一个简单的入口就可以访问了。
另外，类体中安全级别较高的数据封装起来，外部人员不能随意访问，
来保证数据的安全性。

6.3、怎么进行封装，代码怎么实现？
第一步：属性私有化（使用private关键字进行修饰。）
第二步：对外提供简单的操作入口。

 

//带有static的方法
//没有static的方法
//分别怎么调用？
    //带有static的方法怎么调用？通过“类名.”的方式访问。

//对象被称为实例。
//实例相关的有：实例变量、实例方法。
//实例变量是对象变量。实例方法是对象方法。
//实例相关的都需要先new对象，通过“引用.”的方式去访问。
public class MethodTest{

    /*
    public MethodTest(){
    
    }
    */

    public static void main(String[] args){
        MethodTest.doSome();
        //类名. 可以省略（在同一个类中。）
        doSome();
        // 尝试使用“类名.”的方式访问“实例方法”
        // 错误的
        //MethodTest.doOther();
        
        // 创建对象
        MethodTest mt = new MethodTest();
        // 通过"引用."的方式访问实例方法。
        mt.doOther();

    }    

    // 带有static
    public static void doSome(){
        System.out.println("do some!");
    }

    //这个方法没有static，这样的方法被称为：实例方法。（对象方法，对象级别的方法）
    //这个没法解释，大家目前死记硬背。
    public void doOther(){
        System.out.println("do other....");
    }

}

 

/*
空指针异常导致的最本质的原因是？
    空引用访问“实例相关的数据”，会出现空指针异常。

    实例相关的包括：实例变量 + 实例方法。
*/
public class NullPointerTest{
    public static void main(String[] args){
        User u = new User();
        System.out.println(u.id); // 0
        u.doSome();

        // 引用变成空null
        u = null;

        // id的访问，需要对象的存在。
        //System.out.println(u.id); // 空指针异常

        // 一个实例方法的调用也必须有对象的存在。
        //u.doSome(); // 空指针异常。
    }
}


// 类 = 属性 + 方法
// 属性描述状态
// 方法描述行为动作
class User{

    // 实例变量
    int id;

    // 实例方法（对象相关的方法，对象级别的方法，应该是一个对象级别的行为。）
    // 方法模拟的是对象的行为动作。
    public void doSome(){
        System.out.println("do some!");
    }

    // 考试的行为，由于每一个人考试之后的分数不一样，所以考试行为应该必须有对象的参与。
    public void exam(){
        
    }
}

【1】
/*
    Person表示人类：
        每一个人都有年龄这样的属性。
        年龄age，int类型。
    
    我这里先不使用封装机制，分析程序存在什么缺点？
        Person类的age属性对外暴露，可以在外部程序中随意访问，导致了不安全。
    
    怎么解决这个问题？
        封装。
*/

// 这是没有封装的Person。
/*
public class Person{

    // 实例变量(属性)
    int age; //age属性是暴露的，在外部程序中可以随意访问。导致了不安全。

}
*/

// 尝试封装一下
// 不再对外暴露复杂的数据，封装起来
// 对外只提供简单的操作入口。
// 优点：第一数据安全了。第二调用者也方便了。
public class Person{
    // private 表示私有的，被这个关键字修饰之后，该数据只能在本类中访问。
    // 出了这个类，age属性就无法访问了。私有的。
    private int age; // 每一个人年龄值不同，对象级别的属性。

    // 对外提供简单的访问入口(电视机的遥控器就相当于是电视机的访问入口，简单明了。)
    // 外部程序只能通过调用以下的代码来完成访问
    // 思考：你应该对外提供几个访问入口?
    // 思考：这些操作入口是否应该是方法呢？
    // 写一个方法专门来完成读。(get)
    // 写一个方法专门来完成写。(set)
    // get和set方法应该带有static，还是不应该有static,get和set方法应该定义为实例方法吗？
    // get读年龄，set改年龄，这个读和改都是操作的一个对象的年龄。（没有对象何来年龄）
    // 封装的第二步：对外提供公开的set方法和get方法作为操作入口。并且都不带static。都是实例方法。
    /*
        [修饰符列表] 返回值类型 方法名(形式参数列表){
        }

        注意：
            java开发规范中有要求，set方法和get方法要满足以下格式。
                get方法的要求：
                    public 返回值类型 get+属性名首字母大写(无参){
                        return xxx;
                    }
                set方法的要求：
                    public void set+属性名首字母大写(有1个参数){
                        xxx = 参数;
                    }
            
            大家尽量按照java规范中要求的格式提供set和get方法。
            如果不按照这个规范格式来，那么你的程序将不是一个通用的程序。

    */
    // get方法
    public int getAge(){
        return age;
    }

    // set方法
    public void setAge(int nianLing){
        // 能不能在这个位置上设置关卡！！！！
        if(nianLing < 0 || nianLing > 150){
            System.out.println("对不起，年龄值不合法，请重新赋值！");
            return; //直接终止程序的执行。
        }
        //程序能够执行到这里，说明年龄一定是合法的。
        age = nianLing;
    }

}

【2】
// 在外部程序中访问Person这个类型中的数据。
public class PersonTest{
    public static void main(String[] args){
        // 创建Person对象
        Person p1 = new Person();
        // 访问人的年龄
        // 访问一个对象的属性，通常包括两种操作，一种是读数据，一种是改数据。
        // 读数据
        System.out.println(p1.age); //读（get表示获取）

        // 修改数据（set表示修改/设置）
        p1.age = 50;
        
        //再次读取
        System.out.println(p1.age);

        // 在PersonTest这个外部程序中目前是可以随意对age属性进行操作的。
        // 一个人的年龄值不应该为负数。
        // 程序中给年龄赋值了一个负数，按说是不符合业务要求的，但是程序目前还是让它通过了。
        // 其实这就是一个程序的bug。
        p1.age = -100; //改（随意在这里对Person内部的数据进行访问，导致了不安全。）
        System.out.println("您的年龄值是：" + p1.age); //读
    }
}

【3】
public class PersonTest02{
    public static void main(String[] args){
        // 创建对象
        Person p1 = new Person();

        // Person的age，彻底在外部不能访问了。但是这难免有点太安全了。
        // age不能访问，这个程序就意义不大了。
        /*
        // 读age属性的值
        System.out.println(p1.age);

        // 修改age属性的值
        p1.age = 20;

        // 读age
        System.out.println(p1.age);
        */

        // 通过“类名.”可以调用set和get方法吗？不行。
        // 只有方法修饰符列表中有static的时候，才能使用“类名.”的方式访问
        // 错误的。
        //Person.getAge();

        //读调用getAge()方法
        //int nianLing = p1.getAge();
        //System.out.println(nianLing); //0
        //以上代码联合
        System.out.println(p1.getAge()); //0

        //改调用setAge()方法
        p1.setAge(20);

        System.out.println(p1.getAge()); //20

        // 你折腾半天了，这不是结果还是没控制住吗？？？？？？
        p1.setAge(-100);
        //System.out.println(p1.getAge()); // -100
        System.out.println(p1.getAge()); // 20

    }
}

//构造方法、构造器、Constructor【构造函数】
// 只能用new来调用构造方法。
public class Student{

    String no;
    String name;

    // 无参数的构造方法
    public Student(){
    }
    public Student(String s){
        no = s;
    }
    /*
    public Student(String mingZi){
        name = mingZi;
    }
    */
    public Student(String s1, String s2){
        no = s1;
        name = s2;
    }
}

//构造方法两个作用：创建对象  给属性赋值。

class StudentTest{
    public static void main(String[] args){
        Student s = new Student();
        Student s1 = new Student("100");
    }
}