面向对象（一）

一、面向对象的开发、设计以及特征
面向过程：事物比较简单，可以用线性的思维去解决。

面向对象（Oriented Object）
核心：以面向对象的方式来组织代码，封装数据。
面向对象开发：
就是不断的创建对象，使用对象，指挥对象做事情
面向对象设计：
其实就是在管理和维护对象之间的关系
面向对象特征：
封装，继承，多态
采用面向对象的方式思考问题：
考虑有哪些对象。

二、类和对象
如何表示一个现实世界事物呢？
属性 就是该事物的描述信息？
行为 就是该事物能够做什么？

类：是一组相关的属性和行为的集合，是一个抽象的概念。
对象：是该类事物的具体表现形式，具体存在的个体。

三、类的定义概述和学生类的分析
事物：
属性 行为
类：
成员变量
成员方法
定义一个类，其实就是定义该类的成员变量和
成员方法。

例子：学生类的定义

学生事物：
    属性：姓名，年龄，地址...
    行为：学习，吃饭，睡觉...
学生类：
    成员变量：姓名，年龄，地址...
    成员方法：学习，吃饭，睡觉...
成员变量：和以前变量的定义是一样的格式，但是位置不同，在类中方法外。  
成员方法：和以前的方法定义是一样的格式，但是今天把static先去掉。

class Student{

    //定义属性
    //姓名
    string name;
    //年龄
    int age;
    //地址
    string address;

    //定义方法
    //定义学习的方法
        public void study(){
            System.out.println("我爱学习");
        }
    //定义吃饭的方法
        public void eat(){
            System.out.println("学习饿了，要吃饭");
        }
    //定义睡觉的方法
        public void sleep(){
            System.out.println("学习累了，要睡觉");
        }
}

//这是学生测试类
class StudentDemo{
    public static void main(String[] args){
        //类名   对象名  =  new  类名（）；
        Student s = new Student();

        //输出成员变量
        System.out.println(s.name+"---"+s.age+"---"+s.address);

        s.name = "XXX";
        s.age  = 20;
        s.address = "成都";
        System.out.println(s.name+"---"+s.age+"---"+s.address);
        s.study();
        s.eat();
        s.sleep();


    }
}

对象的内存图：

四、成员变量和局部变量的区别
成员变量和局部变量的区别？
A：在类中的位置不同
成员变量：在类中方法外
局部变量：在方法定义中或者方法声明上
B：在内存中的位置不同
成员变量：在堆内存
局部变量：在栈内存
C：生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
D：初始化值不同
成员变量：有默认的初始化值
局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。

    **注意事项：
        局部变量名称可以和成员变量名称一样，在方法中使用的时候，使用的是就近原则

class Variable{
    //成员变量
    //int num = 10;
     int num;
    public void show(){
        //int num2 = 20;//局部变量
        //int num2 ;//可能尚未初始化变量num2
        int num2 = 30;
        System.out.println(num2);
    }
}

class VariableDemo{
    public static void main(String[] args){

        Variable v = new Variable();
        System.out.println(v.num);
        v.show();
    }
}

五、方法的形式参数是类名的时候如何调用
形式参数的问题：
基本类型：形式参数的改变不影响实际参数。
引用类型：形式参数的改变直接影响实际参数。

//形式参数是基本类型
class Demo{
    public int sum(int a, int b){
        return a+b;
    }
}

//形式参数是引用类型
class Student{
    public void study(){
        System.out.println("我爱学习");
    }
}

class StudentDemo{
    //如果你看到一个方法的形式参数是一个类类型（引用类型），这里其实需要的是该类的对象。
    public void show(Student s){//调用的时候，把main方法中的地址传递到了这里 Student s = new Student();
        s.study();
    }
}

class ArgsTest{
    public static void main(String[] args){
        //形式参数是基本类型时的调用。
        Demo d = new Demo();
        int result = d.sum(10,20);
        System.out.println("result:"+result);

        //形式参数是引用类型时的调用
        StudentDemo sd = new StudentDemo();
        Student s = new Student();
        sd.show(s);//把s的地址给到了这里

        }
}

六、栈-堆-方法区
栈：自动分配连续的空间，后进先出。一般情况用来放局部变量
堆：不连续的空间。一般放创建出来的对象（new）
-方法区（在堆中）：存放类的代码信息，static变量 ，常量池

七、匿名对象的使用
匿名对象：没有名字的对象
匿名对象的应用场景：
A：调用方法，仅仅只调用一次的时候。
注意：调用多次的时候，不合适。
那么，这种匿名对象调用有什么好处吗？
有，匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
B：匿名对象可以作为实际参数传递。

class Student{
    public void show(){
        System.out.println("我爱学习！");
    }
}

class StudentDemo{
    public void study(Student s){
        s.show();
    }
}

class NoNameDemo{
    public static void main(String[] args){
        //带名字的调用
        Student s = new Student();
        s.show();
        System.out.println("------------");

        //匿名调用
        new Student().show();
        new Student().show();//这里其实是重新创建了一个新的对象。
        System.out.println("------------");

        //带名字的对象作为实际参数
        StudentDemo sd = new StudentDemo();
        Student ss = new Student();
        sd.study(ss);
        System.out.println("------------");

        //匿名对象作为实际参数
        StudentDemo sdd = new StudentDemo();
        //sdd.study(new Student());
        new StudentDemo().study(new Student());
    }
}