面向对象

面向对象

1. 面向过程与面向对象
   面向过程：在编写代码的每一个具体步骤中，我们都是参与者，需要面对具体的每一个步骤和过程，这就是面向过程，代表语言：C语言
   面向对象：根据不同的功能，将代码进行不同的封装，功能类似的封装在一起，在用的时候，直接找到对应的类创建对象，指挥对象做事情，这里我们担任的是指挥者，这就是面向过程，代表语言：JAVA
   举个例子：
   洗衣服：换下脏衣服—盛水----浸泡------手搓----漂清—晾干（面向过程）
   全自动洗衣机----------- 一键洗衣（面向对象）

2. 面向对象思想特点
   A：是一种更符合我们思想习惯的思想（懒人思想）
   B：可以将复杂的事情简单化
   C：将我们从执行者变成了指挥者

3. 面向对象的三大特征：封装（encapsulation）、继承（inheritance）、多态（polymorphism）

类与对象

在我们给他人描述一个事物的时候，通常就是两点，该事物的属性和该事物的行为
属性：就是该事物的描述信息
行为：就是该事物能够做什么
而我们学习编程语言，就是为了模拟现实中的事物，JAVA最基本单位是类，所以，我们就把事物用一个类来体现，因此，我们可以得到这样一个对应关系

定义一个类就是定义类的成员（成员变量和成员方法）

定义了类之后，我们要用它，就需要创建对象，那么，什么是对象？
类：是一组相关的属性和行为的集合
对象：就是该类事物的具体体现
举个例子：定义了一个学生类，那么，每一个学生就是一个对象

package org.westos.demo;
//定义一个学生类
public class Student {
    //定义成员变量
     String name;
     int age;
    //定义成员方法
     public void method(){
         System.out.println("成员方法得到使用");
     }
}

package org.westos.demo;
//学生类的使用
public class Test {
    public static void main(String[] args) {
        Student student = new Student();//创建对象
        //使用成员变量
        String name = student.name="张三";
        int age = student.age=18;
        System.out.println(name);
        System.out.println(age);
        //使用成员方法
        student.method();
    }
}

在测试类运行代码结果可得

内存图

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

匿名对象

1. 概念：就是没有名字的对象
2. 应用场景：（1）仅仅调用一次方法的时候 （2）作为实际参数传递

构造方法

1. 概述及作用
   创建对象，给对象中的成员进行初始化

2. 格式特点
   （1）方法名与类名相同
   （2）没有返回值类型，连void都没有
   （3）没有具体的返回值

3. 注意事项
   如果没有给出构造方法，系统将自动提供一个无参构造方法，一旦我们给出构造方法，系统将不再提供默认的无参构造方法，建议永远自己给出无参构造方法

4. 构造方法的使用
   一个标准学生类的代码及测试：

package org.westos.demo;
//定义一个标准学生类（成员变量，成员方法，构造方法）
public class Student {
    //定义成员变量
     private String name;
     private int age;
    //无参构造方法
    public Student() {
    }
    //有参构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package org.westos.demo;
//标准学生类的使用
public class Test {
    public static void main(String[] args) {
        Student student = new Student();//创建对象
        //使用无参构造方法
        student.setName("张三");
        student.setAge(18);
        System.out.println(student.getName());
        System.out.println(student.getAge());
        //使用有参构造方法
        Student student1 = new Student("李四",20);
        System.out.println(student1.getName());
        System.out.println(student1.getAge());
    }
}

得到的运行结果：

在创建一个对象时，内存里实现的步骤：
Student s = new Student();
（1）加载Student.class文件进内存
（2）在栈内存为s开辟空间
（3）在堆内存为学生对象开辟空间
（4）对学生对象的成员变量进行默认初始化
（5）对学生对象的成员变量进行显示初始化
（6）通过构造方法对学生对象的成员变量进行赋值
（7）学生对象初始化完毕，把对象地址赋值给s变量
以学生类为例，内存图为：

代码块

1. 概述：在java中，使用{ }括起来的代码被称为代码块
2. 分类：局部代码块，构造代码块，静态代码块，同步代码块（多线程有关）
3. 应用
   A：局部代码块：在方法中出现，限定变量生命周期，及早释放，提高内存利用率
   B：构造代码块：在类中方法外出现，多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
   C：静态代码块：在类中方法外出现，加上static静态修饰，在加载类的时候就执行且只执行一次
   举个例子：

class Student {
		static {
			System.out.println("Student 静态代码块"); //3
		}
		
		{
			System.out.println("Student 构造代码块"); //4 6
		}
		
		public Student() {
			System.out.println("Student 构造方法"); //5 7
		}
	}

	class StudentDemo {
		static {
			System.out.println("StudentDemo的静态代码块");  //1
		}
		
		public static void main(String[] args) {
			System.out.println("我是main方法"); //2 
			
			Student s1 = new Student();
			Student s2 = new Student();
		}
	}

得到的运行顺序结果是：

总结来说，就是先执行静态代码块，且只执行一次，在执行构造代码块，在执行构造方法

扩展知识之随机数

1. Math类概述：类包含用于执行基本数据运算的方法

2. Math类特点：因为在java.lang包下，无需导包；成员均为静态，没有构造方法

3. 获取随机数的方法：public static double random()；
   返回带正号的 double 值，该值大于等于 0.0 且小于 1.0
   例如要获取一个1-100的随机数：int number = (int)(Math.random()*100)+1；

4. 应用：猜数字小游戏

package org.westos.demo;

import java.util.Scanner;

//设计一个猜数字小游戏（1-100之间）
public class Test02 {
    public static void main(String[] args) {
        //系统随机生成一个范围在1-100之间的数
        int num = (int)(Math.random()*100)+1;
        //运用一个死循环，判断输入数字和随机数是否相等，相等则用break结束循环
        while(true){
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入一个数字：");
            int n = sc.nextInt();
            if(n > num){
                System.out.println("太大了，请重试！");
            }else if(n < num){
                System.out.println("太小了，请重试！");
            }else{
                System.out.println("恭喜你，猜中了");
                break;
            }
        }
    }
}

结果为：