面向对象

1.基本要素

属性：用于描述事物的信息 ==》 成员变量：用于描述事物的信息
行为：用来描述事物能够做什么的 ==》 成员方法：用来描述事物能够做什么的
类：是一组成员变量和成员方法的集合，可以把类看作一个抽象的概念 。
对象：是该类的具体的表现，具体到一个个体 。
举例：事物：人
属性：姓名，性别，年龄…
行为：吃饭，睡觉，学习…

    类：Person
        成员变量：name,gender,age
        成员方法：eat(),sleep(),study()
    
    对象：是该类的具体的表现，具体到一个个体
        学生，老师，医生，律师，程序员
   如何定义一个成员变量？
        1、定义的位置：在类中，方法外
        2、定义的格式：
            数据类型 变量名;

   如何定义一个成员方法？
        1、定义的位置：在类中
        2、定义的格式：
            修饰符 返回值类型 方法名(参数列表){
                方法体;
            }

2.类与对象的关系

类相当于抽象的概念
对象是类的具体表现

（1）创建一个对象的内存图

（1）class文件中有两个class文件，phone1.class中有如图三个方法地址为0x001，Phonetest里有一个main方法，地址为0x002.
（2）在栈中执行main方法持行Phone p1=new phone；在堆中开辟空间其地址值为0x001，它有默认值，整体上也会有一个地址为0x0001赋给p1.p1通过地址对其变量进行修改p1.brand等命令。
（3）然后再执行p1.call,p1通过地址去找到方法区如果有call方法，就将该方法加载到栈中执行。当方法执行后就结束了，该方法就会被释放，以此类推其他方法一样。

（2）创建两个对象的内存图

与创建一个变量类似。两个堆内存中的区域都指向同一个方法区

（3）创建三个对象的内存图

与创建两个对象的内存图类似，不同点在于Phone p3=p1;就是将p1的地址0x0001赋给p3，这样p1和p3指得是同一块区域，因此通过p3.brand,p3.price,进而就可以改变该区域的值，最终你输出p1.brand，p1.price,也就和p3的一样同一块区域，因p1的指的值也会改变。

3.定义一个类：

注意事项：一个java文件中只能有一个类被public修饰只需要记住被public修饰的类规范是要与java文件名一致
在一个java文件可以定义多个类，我们这里，就先定义基本的类，和测试类
将来编译的时候，JVM会读取java文件，有多少个class类，就编译生成多少个.class文件

如何创建对象：
    类名 对象名 = new 类名()

通过对象访问成员变量：对象名.非私有的成员变量名
通过对象访问成员变量：对象名.非私有的成员方法

4.封装

我们在定义一个学生类并使用的时候，发现了一个问题：
通过对象给成员变量赋值的时候，可以赋值一些非法的数据。 这样是不合理不符合现实生活的。 我们应该在赋值之前，做一次判断，数据校验，也就是对即将要赋值的数据做判断。
问题又来了，我们应该在哪里定义这个判断逻辑呢？
测试类负责创建对象并使用对象的地方，在这里定义判断逻辑是不合适的。 所以我们这里应该定义在Student3类中。又因为，我们在定义成员变量的时候无法加入逻辑判断。所以，我们在成员方法中定义。因为做数据判断的时候，加的是一些逻辑判断语句，肯定不是只有一条。我们应该在Student3类中提供一个方法来数据校验。
按照我们的想法，在类中提供了一个数值校验的方法，如果符合就成功赋值，反之则不赋值。
但是，谁规定了我定义了方法就一定会被使用呢，如果我还是用之前的获取成员变量的方式进行赋值，问题依旧存在那么我们给出的方法意义就不是很大了。
实际上，我们应该定义了一个方法后，让调用必须使用我们的方法进行赋值，并且不能让调用者直接获取到我们成员变量。
怎么去强制要求不直接获取成员变量呢？
针对这样的情况，java就提供了一个关键字：private
private： 私有的。
其实说到现在，就是为了引出一个思想：封装
封装：其实就是隐藏对象的属性和相关的实现细节，仅仅对外提供公共的访问方式
举例：

       class Student3 {
    //定义成员变量
    String name;
    private int age;

    public void setAge(int a){
        if(a<0 || a>200){
            System.out.println("您要传入的年龄数据有误，请重新赋值");
        }else{
            age = a;
        }
    }

    //定义一个输出所有的成员变量
    public void show() {
        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age);
    }

}
public class StudentDemo2 {
    public static void main(String[] args) {
        //创建一个学生对象
        Student3 s = new Student3();
       

        //给对象的成员变量赋值
        s.name = "马鞍山学院";


//        s.age = 10000; 由于我们在Student3类中name前面加了
//一个private关键字，不可以直接使用获取到成员变量，要想赋值，
                        //就必须使用我们提供的数据校验赋值方法
        s.setAge(10000);
        s.show();

    }
}

5.private关键字：

• 私有的。它可以修饰成员变量和成员方法 被private修饰的成员只能在本类中进行访问。

• 获取成员变量值的方法：
  1、提供一个公共的方法，打印所有的成员变量值
  2、单个使用公共的获取方法，一个一个获取打印（开发）
  原因：单个使用比一起使用的灵活度要高。

• private : 私有的。
  1、它可以修饰成员（成员变量和成员方法）
  2、被private修饰的成员只能在本类中访问使用。其他类中使用不了
  举例：

       class Person {
    //private修饰成员变量
    private String name;
    private int age;

    //提供一个公共set方法
    public void setName(String s) {
        name = s;
    }

    public void setAge(int a) {
        age = a;
    }

    //提供一个公共的get方法，让外界获取到成员变量值
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }


    //打印所有的成员变量值
    private void show() {
   System.out.println("姓名：" + name + ",年龄：" + age);
    }

    public void show2(){
        show();
    }

}
public class PrivateDemo1 {
    public static void main(String[] args) {
        Person p = new Person();
//        System.out.println();
        //调用公共的方法为成员变量进行赋值
        p.setName("小明");
        p.setAge(18);
//        p.show();
        p.show2();

        //调用公共的方法获取成员变量的值
        String name = p.getName();
        System.out.println(name);
        int age = p.getAge();
        System.out.println(age);
    }
}

举例： 练习：请把手机类写成一个标准类的格式，然后创建对象并测试

    手机类：
        成员变量：
            品牌：String brand;
            价格：int price;
            颜色：String color;
        成员方法：
            提供公共的getXxx()和setXxx()
            提供一个方法查看手机详情

   测试类：
        创建手机对象并测试（给成员变量赋值，取值）

class Phone2 {
    //定义成员变量
    private String brand;
    private int price;
    private String color;

    //提供公共的getXxx()和setXxx()方法
    public void setBrand(String s) {
        brand = s;
    }

    public String getBrand() {
        return brand;
    }

    public void setPrice(int p) {
        price = p;
    }

    public int getPrice() {
        return price;
    }

    public void setColor(String s) {
        color = s;
    }

    public String getColor() {
        return color;
    }

    //提供一个公共的方法打印手机详情
    public void show() {
        System.out.println("品牌：" + brand + ",价格：" + price + ",颜色：" + color);
    }
}

public class PrivateTest {
    public static void main(String[] args) {
        //创建一个手机对象
        Phone2 p = new Phone2();

        //给成员变量进行赋值
        p.setBrand("小米");
        p.setPrice(2999);
        p.setColor("黑色");

        //获取成员变量并打印
        //获取手机品牌
        String brand = p.getBrand();
        //获取手机对象p的价格
        int price = p.getPrice();
        //获取手机对象p的颜色
        String color = p.getColor();
  System.out.println("品牌：" + brand + ",价格：" + price
 + ",颜色：" + color);

        //调用方法打印所有的成员变量值
        p.show();

    }
}

6.成员变量与局部变量的区别

（1）区别

• 在类中定义的位置不同
  成员变量：类中，但是在方法外
  局部变量：定义在方法内部

• 在内存中的位置也不同
  成员变量：在堆内存中
  局部变量：在栈内存中

• 初始化值也不同
  成员变量：系统会给予默认值
  局部变量：没有系统给的默认值，必须在定义的时候赋值，亦
  或者在方法中使用之前赋值，然后才能使用。

• 生命周期不同
  成员变量的生命周期：随着对象的创建而创建，随着对象的消失而消失
  局部变量的生命周期：随着方法的调用而创建，随着方法的调用完毕而消失

（2） 注意事项：

• 局部变量的名字可以和成员变量的名字一样，在方法中使用的时候，采用就近原则
  方法中使用的变量，会先在方法内部查找，如果方法内部没有，去成员变量中查找。

• 方法与方法之间里面的局部变量变量，不能互相调用。
  举例：

class BianLiang{
    String name;
    int age;

    public void show(int n){//n就是一个局部变量
        n = 10;
        int a = 20;
//        int b;
//        System.out.println(b);
        System.out.println(n);
        System.out.println(a);

        String name = "马原";
        System.out.println(name);
    }

//    public void show2(){
//        System.out.println(a);
//    }

}

public class BianLiangDemo {
    public static void main(String[] args) {
        //成员变量的使用，需要创建对象（最起码这里是要创建对象才能使用的）
        BianLiang b1 = new BianLiang();
        b1.name = "思修";
        System.out.println(b1.name);

        b1.show(100);


    }
}

7.形式参数的问题：分别是基本数据类型和引用数据类型的时候的区别。

（1）当形式参数是基本数据类型的时候,将来调用方法的时候传入的是常量值,或者是该类型的变量

（2）当形式参数是引用数据类型的时候，将来调用方法的时候传入的是该类对象的地址值

（3）当形式参数是基本数据类型的时候，在方法中对变量做修改，不会影响到外部实际的栈内存中的值。因为在方法调用完成后方法会在栈中消失，因此无论你怎么在方法中对变量进行修改也不回影响到外部的参数。

（4）当形式参数是引用数据类型的时候，在方法中对变量做修改，会影响到外部实际的堆内存中的值。

举例:

class Demo2 {
    public int getSum(int a,int b) {
        a=100;
        b=200;
        return a + b;
    }
}

class Student2{
    String name;
    public void speak(){
        System.out.println("我热爱学习");
    }
}

class StudentTest2{
/* 如果将来你看到一个方法的形式参数是一个类的类型，说明他是一个引用
数据类型
  这里其实需要的是该类的对象
 调用的时候，把main方法中创建好的对象名传过来，实际上传的就是对象
 	的地址值
     * @param s
     */
    public void function(Student2 s){ //Student2 s = new Student2();
        s.name = "小王";
        s.speak();
    }
}


public class XingShiCanShuDemo {
    public static void main(String[] args) {
        Demo2 d = new Demo2();
        int a = 10;
        int b = 20;
        System.out.println(d.getSum(a,b));
        System.out.println("a:"+a+",b:"+b);

        //要想调用function(),就必须创建StudentTest2对象
        StudentTest2 st2 = new StudentTest2();

        Student2 student2 = new Student2();
        System.out.println(student2.name);
        st2.function(student2);/*当你调用function的时候实际
   上就是传递了student2的地址，当你在function中对name的值做出
   改变时，虽然function随着调用完成而消失，但事实上两者的地址值相
   同指得时同一个name，最终name会发生变化。还得注意这里调用
   function时传入参数是student2所创建的一个对象，也相当于将
   student2的地址上传*/
        System.out.println(student2.name);
    }
}

（5）基本数据类型当作参数传递时的内存图

（6）引用数据类型当作参数传递时的内存图

8.匿名对象

(1).匿名对象：就是没有名字对象

(2) 匿名对象的使用场景：

• 调用方法的时候，仅仅调用一次的时候，可以使用匿名对象
  注意：当调用多次的时候，不适合,每次new的时候都是一个新的匿名对象，会频繁的在堆内存中开辟空间
  当匿名对象使用完毕之后，无法再使用第二次，就变成了一个垃圾（当栈中没有变量引用它的时候，判定是一个垃圾），等待被垃圾回收器回收。
• 当方法的参数类型是一个类的时候，可以使用匿名对象调用方法。

举例：

class Phone4{
    public void show(){
        System.out.println("手机可以打电话");
    }
}

class PhoneDemo{
    public void function(Phone4 p){
        p.show();
    }
}

public class AnonymousDemo {
    public static void main(String[] args) {
        //创建一个PhoneDemo对象
        PhoneDemo pd = new PhoneDemo();
        Phone4 phone = new Phone4();
        pd.function(phone);

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

 //当new完对象之后直接使用，没有用变量名接收的对象，称之为匿名对象
        new PhoneDemo().function(new Phone4());
        new PhoneDemo().function(new Phone4());


    }

}

9.this关键字

（1）this代表的是将来调用该方法的对象。进而得到标准类写法2.0版本

（2） 定义一个医生类：

class Doctor {
    private String name;
    private int age;
    private String gender;

    public void setName(String name) {
        /*我们还说过，局部变量的使用原则：就近原则我们这里的name
 采用就近原则后发现，使用的都是形参的变量名name，没有使用成员变量中
 name.我们理想上应该是将传进来的name赋值给调用该方法对象中的成员变
 量name
  Doctor.name = name;直接通过类名.成员变量的方式目前是不行，我们
  还没有说过类似的用法，所以这个是有问题的
  如果这个Doctor对象存在的话，它是不是就表示了一个医生对象
    如果有一个东西可以代表是当前调用该方法的对象就好了
      java提供了一个关键字：this
     this在方法中使用的时候，就代表着调用该方法的对象
        既然都是一个对象了，我们学过对象.成员变量*/
//此种方法不行        Doctor.name = name;
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int i) {
        age = i;//此种类型并不能达到我们前面所说的见名知意的效果，但如果我们把它改为age=age的话运行后发现结果不对，值没有赋上。
    }

    public int getAge() {
        return age;
    }

    public void setGender(String s) {
        gender = s;
    }

    public String getGender() {
        return gender;
    }

    //提供一个公共的方法
    public void show() {
        System.out.println("姓名：" + name + ",年龄：" + age + ",性别：" + gender);
    }

}

public class DoctorDemo {
    public static void main(String[] args) {
        //创建一个医生对象
        Doctor d = new Doctor();

        d.setName("王宇");
        d.setAge(18);
        d.setGender("男");
        d.show();
    }
}

（3）下面说说this在内存中的位置

（1）首先方法区中class文件区有两个class一个是DoctorDemo2.class这个class中包含着main方法即地址为0x001.另一个为Doctor2.class即地址为0x002这其中包含getx（）/setxxx()/show()
方法
（2）再将main方法加载到栈中执行，然后在main中开辟一个Doctor2 d空间，再在堆中new一个Doctor2（），其中包含name，age，gender其地址是0x002，堆内存中会有默认值
而这个new Doctor2（）本身也有一个地址值假设为0x0001，然后将这个地址赋给d，d就可以通过这个地址找到其区域。
（3）this在对象创建之前this就已经指向堆内存中的那块区域，this就代表它所指区域的对象。这样就可以通过this去找到方法区从而去可以调方法。