java基础（六）

面向对象思想概述

　　* A:面向过程思想概述
　　　　* 第一步
　　　　* 第二步
　　* B:面向对象思想概述
　　　　* 找对象(第一步,第二步)
　　* C:举例
　　　　* 买煎饼果子
　　　　* 洗衣服
　　* D:面向对象思想特点
　　　　* a:是一种更符合我们思想习惯的思想
　　　　* b:可以将复杂的事情简单化
　　　　* c:将我们从执行者变成了指挥者
　　　　　　* 角色发生了转换
　　* E:面向对象开发
　　　　* 就是不断的创建对象，使用对象，指挥对象做事情。
　　* F:面向对象设计
　　　　* 其实就是在管理和维护对象之间的关系。
　　* G:面向对象特征
　　　　* 封装(encapsulation)
　　　　* 继承(inheritance)
　　　　* 多态(polymorphism)

类与对象概述

　　A:我们学习编程是为了什么
　　　　* 为了把我们日常生活中实物用学习语言描述出来
　　* B:我们如何描述现实世界事物
　　　　* 属性就是该事物的描述信息(事物身上的名词)
　　　　* 行为就是该事物能够做什么(事物身上的动词)
　　* C:Java中最基本的单位是类,Java中用class描述事物也是如此
　　　　* 成员变量就是事物的属性
　　　　* 成员方法就是事物的行为
　　* D:定义类其实就是定义类的成员(成员变量和成员方法)
　　　　* a:成员变量和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
　　　　* b:成员方法和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
　　* E:类和对象的概念
　　　　* a:类：是一组相关的属性和行为的集合
　　　　* b:对象：是该类事物的具体体现
　　* c:举例：
　　　　* 类学生
　　　　* 对象具体的某个学生就

成员变量和局部变量的区别

　　* A:在类中的位置不同
　　　　* 成员变量：在类中方法外
　　　　* 局部变量：在方法定义中或者方法声明上
　　* B:在内存中的位置不同
　　　　* 成员变量：在堆内存(成员变量属于对象,对象进堆内存)
　　　　* 局部变量：在栈内存(局部变量属于方法,方法进栈内存)
　　* C:生命周期不同
　　　　* 成员变量：随着对象的创建而存在，随着对象的消失而消失
　　　　* 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
　　* D:初始化值不同
　　　　* 成员变量：有默认初始化值
　　　　* 局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
　　
　　* 注意事项：
　　　　* 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
　　　　* 基本数据类型变量包括哪些:byte,short,int,long,float,double,boolean,char
　　　　* 引用数据类型变量包括哪些:数组,类,接口,枚举

封装的概述

　　* A:封装概述
　　　　* 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

　　* B:封装好处
　　　　* 隐藏实现细节，提供公共的访问方式
　　　　* 提高了代码的复用性
　　　　* 提高安全性。
　　* C:封装原则
　　　　* 将不需要对外提供的内容都隐藏起来。
　　　　* 把属性隐藏，提供公共方法对其访问。

this关键字的概述和应用

　　* A:this关键字特点
　　　　* 代表当前对象的引用
　　* B:案例演示
　　　　* this的应用场景
　　　　* 用来区分成员变量和局部变量重名

构造方法Constructor概述和格式

　　* A:构造方法概述和作用
　　　　* 给对象的数据(属性)进行初始化
　　* B:构造方法格式特点
　　　　* a:方法名与类名相同(大小也要与类名一致)
　　　　* b:没有返回值类型，连void都没有
　　　　* c:没有具体的返回值return;

class Person {
    private String name;            //姓名
    private int age;                //年龄

    public Person() {                //空参构造
        System.out.println("空参的构造");
    }

    public Person(String name,int age) {
        this.name = name;
        this.age = age;
        System.out.println("有参的构造");
    }
    
    public void show() {
        System.out.println(name + "..." + age);
    }
}

构造方法
　　给属性进行初始化
setXxx方法
　　修改属性值
这两种方式,在开发中用setXxx更多一些,因为比较灵活

class Demo3_Person {
    public static void main(String[] args) {
        Person p1 = new Person("张三",23);
        //p1 = new Person("张天一",23);    //这种方式看运行结果貌似是改名了,其实是将原对象变成垃圾
        System.out.println(p1.getName() + "..." + p1.getAge());

        System.out.println("--------------------");
        Person p2 = new Person();        //空参构造创建对象
        p2.setName("李四");
        p2.setAge(24);

        p2.setName("李鬼");
        System.out.println(p2.getName() + "..." + p2.getAge());
    }
}
/*
构造方法
    给属性进行初始化
setXxx方法
    修改属性值
    这两种方式,在开发中用setXxx更多一些,因为比较灵活
*/
class Person {
    private String name;                //姓名
    private int age;                    //年龄

    public Person() {                    //空参构造
    }

    public Person(String name,int age) {//有参构造
        this.name = name;
        this.age = age;
    }
    
    public void setName(String name) {    //设置姓名
        this.name = name;
    }

    public String getName() {            //获取姓名
        return name;
    }

    public void setAge(int age) {        //设置年龄
        this.age = age;
    }

    public int getAge() {                //获取年龄
        return age;
    }
}

创建一个对象的步骤

　　* A:画图演示
　　　　* 画图说明一个对象的创建过程做了哪些事情?
　　　　* Student s = new Student();
　　　　* 1,Student.class加载进内存
　　　　* 2,声明一个Student类型引用s
　　　　* 3,在堆内存创建对象,
　　　　* 4,给对象中属性默认初始化值
　　　　* 5,属性进行显示初始化
　　　　* 6,构造方法进栈,对对象中的属性赋值,构造方法弹栈
　　　　* 7,将对象的地址值赋值给s

static关键字及内存图

static关键字的特点

　　* A:static关键字的特点
　　　　* a:随着类的加载而加载
　　　　* b:优先于对象存在
　　　　* c:被类的所有对象共享
　　　　* 举例：咱们班级的学生应该共用同一个班级编号。
　　　　* 其实这个特点也是在告诉我们什么时候使用静态?
　　　　* 如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
　　　　* 举例：
　　　　　　* 饮水机(用静态修饰)
　　　　　　* 水杯(不能用静态修饰)
　　　　* 共性用静态,特性用非静态
　　* d:可以通过类名调用
　　　　* 其实它本身也可以通过对象名调用。
　　　　* 推荐使用类名调用。
　　　　* 静态修饰的内容一般我们称其为：与类相关的，类成员

static的注意事项

　　* A:static的注意事项
　　　　* a:在静态方法中是没有this关键字的
　　　　　　* 如何理解呢?
　　　　　　　　* 静态是随着类的加载而加载，this是随着对象的创建而存在。
　　　　　　　　* 静态比对象先存在。
　　　　* b:静态方法只能访问静态的成员变量和静态的成员方法
　　　　　　* 静态方法：
　　　　　　　　* 成员变量：只能访问静态变量
　　　　　　　　* 成员方法：只能访问静态成员方法
　　　　　　* 非静态方法：
　　　　　　　　* 成员变量：可以是静态的，也可以是非静态的
　　　　　　　　* 成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
　　　　* 简单记：
　　　　　　* 静态只能访问静态。

class Demo2_Static {
    public static void main(String[] args) {
        //Demo d = new Demo();
        //d.print1();

        Demo.print2();
    }
}

/*
* A:static的注意事项
    * a:在静态方法中是没有this关键字的
        * 如何理解呢?
            * 静态是随着类的加载而加载，this是随着对象的创建而存在。
            * 静态比对象先存在。
    * b:静态方法只能访问静态的成员变量和静态的成员方法
        * 静态方法：
            * 成员变量：只能访问静态变量
            * 成员方法：只能访问静态成员方法
        * 非静态方法：
            * 成员变量：可以是静态的，也可以是非静态的
            * 成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
        * 简单记：
            * 静态只能访问静态。
*/

class Demo {
    int num1 = 10;                        //非静态的成员变量
    static int num2 = 20;                //静态的成员变量

    /*public void print1() {                //非静态的成员方法,既可以访问静态的成员也可以访问非静态的
        System.out.println(num1);
        System.out.println(num2);
    }*/

    public static void print2() {        //静态的成员方法
        //System.out.println(this.num1);//静态的成员方法不能访问非静态的,错误: 无法从静态上下文中引用非静态 变量 num1
        System.out.println(num2);
    }
}

静态变量和成员变量的区别

　　* 静态变量也叫类变量成员变量也叫对象变量
　　* A:所属不同
　　　　* 静态变量属于类，所以也称为为类变量
　　　　* 成员变量属于对象，所以也称为实例变量(对象变量)
　　* B:内存中位置不同
　　　　* 静态变量存储于方法区的静态区
　　　　* 成员变量存储于堆内存
　　* C:内存出现时间不同
　　　　* 静态变量随着类的加载而加载，随着类的消失而消失
　　　　* 成员变量随着对象的创建而存在，随着对象的消失而消失
　　* D:调用不同
　　　　* 静态变量可以通过类名调用，也可以通过对象调用
　　　　* 成员变量只能通过对象名调用

* int number = (int)(Math.random()*100)+1;