类，对象，成员变量和局部变量，匿名对象

类是一组相关的属性和行为的集合
属性- 成员变量
行为- 成员方法
成员变量，可以有很多个 零值
成员方法，也可以有很多个，到底具体写几个，看具体的需要
自定义类型的 对象创建 的格式

// 自定义的类型 对象名 = new 自定义类型();
Person person = new Person();

如何使用对象，使用对象其实是使用对象中的成员（成员变量，成员方法）
格式：对象名.成员变量 或者 对象名.成员方法（）
取值. 读操作

// 调用成员方法
// 对象名.成员方法（）;
person.eat();

类与对象的创建内存布局图
一个对象：
一个对象的基本初始化过程
两个对象：
方法的共用
三个对象：
其中有两个引用指向同一个对象

package com.newedu.jb.day06;
/**
 * 定义一个学生类
 * @author 小可爱
 *
 */
public class Student {
    //成员变量
    String name; //默认值 null

    int age;//默认值 0

    String school; //默认值 null

    //成员方法

    public void eat(){
        System.out.println("eat()方法被调用了");
    }

    public void sleep(){
        System.out.println("sleep()方法被调用了");
    }

    public void study(){
        System.out.println("Student()方法被调用了");
    }

    public void showInfo(){
        System.out.println("name:"+name+" age:"+age+" school:"+school);
    }
}

package com.newedu.jb.day06;
/**
 * 自定义类Student的测试类
 * @author 小可爱
 *
 */
public class StudentDemo {
    public static void main(String[] args) {
//      int i ;
//      System.out.println(i);

        //创建一个对象
        Student student = new Student();
        student.showInfo();

        //调用对象的成员变量   读值
        System.out.println(student.name);
        System.out.println(student.age);
        System.out.println(student.school);

        //给对象的成员变量赋值  写值
        student.name = "尚文旭";
        student.age = 20;
        student.school = "中原工学院";

        //调用对象的成员变量   读值
        System.out.println(student.name);
        System.out.println(student.age);
        System.out.println(student.school);

        //如何调用成员方法呢？
        student.eat();
        student.sleep();
        student.study();
        student.showInfo();

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

        //创建第二个学生对象
        Student student2 = new Student();
        //调用对象的成员变量 ，读值
        System.out.println(student2.name); //输出null
        System.out.println(student2.age); // 0
        System.out.println(student2.school); // 输出null

        //给对象的成员变量赋值 写值
        student2.name = "泡泡";
        student2.age = 18;
        student2.school = "软件学院";

        //调用对象的成员变量 ，读值
        System.out.println(student2.name); //输出新值"泡泡"
        System.out.println(student2.age);//输出新值 18
        System.out.println(student2.school); //输出新值"软件学院"

        //调用对象的成员方法

        student2.eat();
        student2.sleep();
        student2.study();
        student2.showInfo();

        System.out.println("======================");
        // int[] array1 = new int[3];
        // int[] array2 = array1;
        //Student student = new Student();
        // Student类型  对象名 =
        Student student3 = student;

        System.out.println(student3.name);//输出 “尚文旭”
        System.out.println(student3.age);//输出  20
        System.out.println(student3.school); //输出 “中原工学院"

        //给成员变量赋值
        student3.name = "peter";
        student3.age = 21;

        student3.showInfo();
        student.showInfo();
    }
}

成员变量和局部变量的区别
在类中的位置不同
成员变量 类中方法外
局部变量 方法内或者方法声明上
在内存中的位置不同
成员变量 堆内存
局部变量 栈内存
生命周期不同
成员变量 随着对象的存在而存在，随着对象的消失而消失
局部变量 随着方法的调用而存在，随着方法的调用完毕而消失
初始化值不同
成员变量 有默认的初始化值
局部变量 没有默认的初始化值，必须先定义，赋值，才能使用。
基本类型作为形式参数
引用类型作为形式参数（自定义类作为参数）
基本数据类型和引用数据类型作为方法的参数传递后，
在方法内对参数进行修改，是否会对参数产生影响的问题？

基本数据类型作为方法的形式参数时，做的是“值传递”
引用数据类型作为方法的形式参数时，做的也是“值传递”，但是这次传递的内存地址值
（两个变量引用了同一块内存地址值。）

package com.newedu.jb.day06;
/**
 * 演示形式参数的问题：
 *     自定义类型做为形式参数的问题
 * @author 小可爱
 *
 */
public class ParameterMethod {
    public void change(int a ,int b){
        // 这里的a和b 是重新定义的局部变量（是因为在方法内定义的） a = 10,b = 20;
        a *=2; // 20;
        b +=a; // 40
        // 一旦离开了 方法体，这里面的局部变量a和b就消失了
    }
    /**
     * 自定义类型Student作为形式参数传递
     * 引用类型作为形式参数传递
     * @param stu
     */
//  public void change2{
//     Student stu ;
    // stu  = new Student();
    // Student stu2 = new Student();
    // stu = stu2;
//}
    public void change2(Student  stu){
        // 相当于 在这里定义了一个Student对象 stu; Student stu = ?
        //给我们的成员变量 age加上100
        stu.age += 100;
        //调用 成员方法()
        stu.showInfo();
    }
}

package com.newedu.jb.day06;
/**
 * 测试类，演示自定义类型作为形式参数的问题
 * @author 小可爱
 *
 */
public class ParameterMethodDemo {
    public static void main(String[] args) {

        //创建一个对象
        ParameterMethod pm = new ParameterMethod();

        int a = 10;
        int b = 20;
        System.out.println("a:"+a+"b:"+b); //a:10 b:20
        //调用对象的成员方法
        pm.change(a, b);
        System.out.println("a:"+a+"b:"+b); // a:10 b:20
                                           // a:20 b:40

        System.out.println("=================");
        Student stu = new Student();
        stu.showInfo(); // name:null age:0 school:null
        pm.change2(stu);
        stu.showInfo(); // name:null age:100 school:null
    }
}

匿名对象：
匿名对象：就是没有名字的对象。
是对象的一种简化表示形式
匿名对象的两种使用情况
对象调用成员仅仅一次的时候
作为实际参数传递
代码举例：

package com.newedu.jb.day06;
/**
 * 匿名对象的创建与使用
 * @author 小可爱
 *
 */
public class AnonymityObjectDemo {
    public static void main(String[] args) {
        // 匿名对象，就是没有名字的对象

//      Student stu = new Student();

        (new Student()).name = "尚文旭";
        new Student().age = 20;

        new Student().showInfo();

        // 匿名对象有短板： 只能用一次。

        // 匿名对象的用途：
        // A：对象调用成员仅仅一次的时候
        // B：作为实际参数传递
        ParameterMethod pm  = new ParameterMethod();
//      Student stu = new Student();
        pm.change2(new Student());

    }
}