JAVA:类与对象（二）构造方法与封装初步（待修改）

整理自动力节点java课堂笔记（感谢老杜）

    构造方法
        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
    }
}
/*
	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 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 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 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、画内存图注意事项：

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

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

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

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

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

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.实例变量在类加载是初始化吗？实例变量在什么时候初始化？

6、封装

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

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

        那么封装，你觉得有什么用呢？
            封装的作用有两个：
                第一个作用：保证内部结构的安全。
                第二个作用：屏蔽复杂，暴露简单。
            
        在代码级别上，封装有什么用？
            一个类体当中的数据，假设封装之后，对于代码的调用人员来说，
            不需要关心代码的复杂实现，只需要通过一个简单的入口就可以访问了。
            另外，类体中安全级别较高的数据封装起来，外部人员不能随意访问，
            来保证数据的安全性。
        
    6.3、怎么进行封装，代码怎么实现？
        第一步：属性私有化（使用private关键字进行修饰。）
        第二步：对外提供简单的操作入口。