面向对象的思想（类与对象及其应用）、成员变量和局部变量、匿名对象、 封装(private) 、this关键字

面向对象

面向对象的的思想就是先根据不同的功能将代码进行封装，等到用的时候直接找到对应的类调用就可以了，不用自己再一个个敲代码。
面向对象思想特点：

 a:是一种更符合我们思想习惯的思想 懒人思想
 b:可以将复杂的事情简单化 
 c:将我们从执行者变成了指挥者
   角色发生了转换

面向对象特征:

封装(encapsulation)
继承(inheritance)
多态(polymorphism)  

面向对象开发

就是不断的创建对象，使用对象，指挥对象做事情。

类

首先我们得定义一个类，定义类其实就是定义类的成员(成员变量和成员方法)

a:成员变量 和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
b:成员方法 和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。

类和对象的概念
类创建好之后，我们要怎么去调用它呢?类是一个抽象化的概念，我们想要调用它，就得创建一个该类的对象，通过对象去调用它。

a:类：是一组相关的属性和行为的集合
 b:对象：是该类事物的具体体现

比如：
类 ------ 学生
对象------ 班长就是一个对象
你要指挥学生做事情，就得通过班长下命令。差不多就这种意思。
创建对象方法：格式：类名 对象名 = new 类名();
怎么使用成员变量： 格式：对象名.变量名

如何使用成员方法： 格式：对象名.方法名(…)

import java.util.Scanner;
public class MyTest {
    public static void main(String[] args) {
        //如果使用定义好的一个类
        // 类：他是一个抽象的概念，他不能直接使用，如果要使用，我们需要对类进行实例化
        //所谓实例化，就是创建该类对象，因为对象才是类的具体表现
        // 怎么创建一个类的对象呢，使用关键字new
        Person person = new Person();
        //该类对象创建成功后，使用该类对象，就可以调用类中的属性和功能
        //先给属性赋值
        person.name = "王五";
        person.age = 23;
        person.sex = '男';
        //获取属性的值
        String name = person.name;
        int age = person.age;
        char sex = person.sex;
        System.out.println(name);
        System.out.println(age);
        System.out.println(sex);
        //使用功能
        person.eat();
        person.sleep();
        person.playGame();
    }
}



public class Person { //定义一个类：class
    //成员属性，成员变量：定义在类中方法外
    String name="zhangsan";
    int age;
    char sex;
    //成员功能，成员方法
   	 public void eat() {
        System.out.println("吃饭");
    }

	public void sleep() {
        System.out.println("睡觉");
    }

	 public void playGame() {
        System.out.println("打豆豆");
    }
}

创建对象内存图：

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

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

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

public class MyTest2 {
    public static void main(String[] args) {
        Student student = new Student();
        student.show("王五");
    }
}

class Student {
    String name="张三";
public void show(String name) {
        //当成员变量和局部变量重名时，那么访问变量的规则就遵从就近原则
        //就近原则：先从局部范围找，找个变量，找到就使用，如果找不到，去成员位置找，找到就成员
         System.out.println(name);//王五
        System.out.println(this.name);//张三
    }
}

方法的形式参数是可以是类名：
如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。
形式参数：
如果是基本类型：形式参数的改变不影响实际参数
如果是引用类型：形式参数的改变直接影响实际参数

public class MyTest {
    public static void main(String[] args) {
        //当你以后看到一个方法的形参，要一个 类 类型。你就传该类的一个对象
        Teacher teacher = new Teacher();
        // System.out.println(teacher);
        show(200, teacher);
        int age = teacher.age;
        System.out.println(age); //
    }
    
    public static void show(int num, Teacher teacher) {
        //System.out.println(teacher);
        System.out.println(num);
        teacher.age = 20;
        teacher.test(50);
    }
}

class Teacher {
    int age;
    public void test(int n) {
        this.age = n;
        System.out.println(age);
    }
}

匿名对象： 就是没有名字的对象，例如 new student(）；创建了一个student类的匿名对象

匿名对象应用场景：
a:调用方法，仅仅只调用一次的时候。
b:匿名对象可以作为实际参数传递

封装

是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

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

封装就要利用private这个关键字
private关键字特点：
a:是一个权限修饰符
b:可以修饰成员变量和成员方法
c:被其修饰的成员只能在本类中被访问

private最常见的应用：
(1):把成员变量用private修饰
(2):提供对应的getXxx()和setXxx()方法

public class Person {
    //private 私有的，是一个权限修饰符，可以修饰成员变量和成员方法，修饰后，该成员只能在本类中访问
    private String name;
    private int age;
    //get set 方法的规范
    //提供一个公共的赋值的方法
    public void setAge(int nianLing) {
        if (nianLing >= 0 && nianLing <= 100) {
            age = nianLing;
        } else {
            System.out.println("这个年龄的数据不合理");
        }
    }
    public void setName(String mingzi) {
        name = mingzi;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    private void show() {
        System.out.println(name);
        System.out.println(age);
    }
}



public class MyTest {
    public static void main(String[] args) {
        //我们通过 对象名.属性名=值 这种赋值方式，不能验证数据的合理性
        //我们现在想要对赋值的数据进行合理性的验证，需要屏蔽掉 对象名.属性名=值 这种赋值方式
        //怎么来屏蔽掉呢?可以使用一个关键字private 私有的，是一个权限修饰符
        Person p = new Person();
               //设置值
        p.setName("张三");
        p.setAge(20);
        //获取属性值的方法
        int age = p.getAge();
        String name = p.getName();
        System.out.println(name);
        System.out.println(age);
        }
      }

this关键字

上面我们讲就近原则的时候用到了this这个关键字，接下来就讲一下this的用法。

为什么要有this？

当我们的局部变量和成员变量相同的时候,如果我们不使用this关键字,因为就近原则，就会导致一个问题:就是局部变量隐藏了成员变量的问题。

this关键字特点：

是当前类的对象引用。
简单的记，它就代表当前类的一个对象。谁调用这个方法,那么该方法的内部的this就代表谁

this的应用场景:

解决局部变量隐藏成员变量

public class Test {
    public static void main(String[] args) {
        Phone phone = new Phone();
        System.out.println(phone+"调用者的地址值");
        phone.setName("小米");
        phone.setPrice(500);

	String name = phone.getName();
        double price = phone.getPrice();
        System.out.println(name+"===="+price);

	 System.out.println("------------------------");
        Phone phone2 = new Phone();
        System.out.println(phone2 + "调用者的地址值");
        phone2.setName("小米");
        phone2.setPrice(500);

	String name2 = phone2.getName();
        double price2 = phone2.getPrice();
        System.out.println(name2 + "====" + price2);
    }
}


public class Phone {
    //私有成员变量
    //this 表示本类的一个引用。你可以理解为本类的一个对象，哪个对象调用这个方法，那么方法中的this就代表这个对象
    private String name;
    private double price;
    //提供公共的set get 方法
    public void setName(String name){
        //方法中的this 就代表那个调用者，谁调用就代表谁
       // p.name=name;
        //就近原则
        System.out.println("this代表调用者的地址值"+this);
        this.name=name;
    }
    public void setPrice(double price){
       // p.price=price;
        System.out.println("this代表调用者的地址值" + this);
        this.price=price;
    }
    public String getName(){
        return name;
    }
    public double getPrice(){
        return price;
    }
}

再见-_-||