面向对象的案例解释代码含义；

-通过给定的题目分析类的属性与方法；

package Diyitongjin.Lianxi_01.shiuji;
/*定义一个类，用来模拟手机事物
*手机事物有两个组成部分
* 属性（成员变量）品牌，价格，颜色
* 行为（方法） 打电话，发短息
* 对应到类中，也有两个部分（）
* */
public class Pnone {
    String brand; //品牌
    double price;//价格
    String color;//颜色
    //成员方法
    public void call(String who)//参数是谁打电话，参数就是谁。
    {
        System.out.println("给"+who+"打电话，请求援兵");
    }
    public void sendIdea(){//参数根据题目定  想有就有 无参  群发短信
        System.out.println("发个短信，祝福");
    }

}

=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

根据类进行实例化，创建对象，调用方法（有参方法要 传递值），成员变量（赋值）

package Diyitongjin.Lianxi_01.shiuji;
/*如何使用定义好的类
*
* 类是一种引用性数据，使用起来分为三个步骤；
*
* 1，导包
*   如果是用的目标类 和当前类位于一个包下 可以不用导包（省略导包不写）
*       否则需要import 导包
* 2.创建
* 类名称 对象名=new 类名称（）；
* 3.使用
* 调用成员变量 （对象名.属性）
* 调用成员 方法 （对象名.方法名）
* */
public class Shilihua {
    public static void main(String[] args) {
         Pnone ipone=new Pnone();//实例化类  创建一个手机对象

        System.out.println(ipone.brand);//null;  访问成员变量的默认值
        System.out.println(ipone.price);//0.0
        System.out.println(ipone.color);//null
        System.out.println("=====================");
        ipone.brand="ipone";
        ipone.price=9999;
        ipone.color="天空灰";
        System.out.println(ipone.brand);//ipone
        System.out.println(ipone.price);//9999
        System.out.println(ipone.color);//天空灰
        System.out.println("=====================");
        //调用成员方法
        ipone.call("王美丽护法");//含有一个String 类型的参数，所以在对调用方法的时候
        //给方法添加一个值（王美丽护法）
        ipone.sendIdea(); //没有参数的方法，在调用的时候不用，给值，

          直接打印输出方法的方法体内容

    }
}

==============================================================

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

1.定义的位置不同

局部变量：定义在方法内，成员方法的参数其实是一个局部变量；

成员变量：直接定义在类中，在方法外面

2.内存中的位置不一样

局部：在栈当中stack      成员 在堆当中 heap

3.生命周期不一样

局部：随着方法的进栈而出现，随着方法的出栈而消失

成员：随着对象创建而出现，随着对象被JVM回收而消失

4.默认值不一样

局部：必须赋值，不赋值，不能用

成员：如果没有赋值，有默认值。

============================================

一、Geter和Seter 用法

package Diyitongjin.Lianxi_01.person;
/*对类进行实例化的时候  其中如果 对象的 年龄属性不符合现实情况；但是却无法控制其
*取值范围，数据不安全，
* 解决办法；使用private;
* 一但使用private 关键字对成员进行了保护，那么超出了本类范围 ，就不能直接访问；
* 如果需要使用 private 修饰的成员变量，可以使用“简介访问”
* 为这个 private 成员变量 编写一对 Seter  Geter  方法
* */
public class Person {
    private int age;//保护属性  私有
    String name;
    //c成员方法
    public void show(){
        System.out.println("我叫"+name+", 今年"+age+"岁");
    }
    //专门用来设置成员变量数据的方法  Seter
    public void setAge(int num){//返回值类型必须是 void,
        // 参数类型 必须与与成员变量 类型一样
        if(num<0 ||num >200){//设置安全性，合理性检测，对数据进行把关
            System.out.println("数据错误");
        }else{
            age=num;
        }
    }//专门用来获取成员变量  数据的 方法；
    public int  getAge(){//返回值类型必须与成员变量 类型一样
        return age;//直接返回
    }
}

package Diyitongjin.Lianxi_01.person;

public class Dee {
    public static void main(String[] args) {
        Person m= new Person();
        m.show();
        m.name="王美丽";
        //m.age=-10;//不合理，错误写法 private 内容不能直接访问
        m.setAge(20);//用间接访问，能够保证数据的合理性，
        //在方法中可以限制方法体
        m.show();
    }
}

=====================================================

二、this关键字，解决重名问题； 

package LIANXI.this_01;
/*当局部变量和成员变量重名时，方法当中会根据“就近原则”使用；
* 如果需要区分一下，就要用到关键字，
* this.成员变量名   调用当前对象的成员变量
* this关键字的经典作用，将重名的成员变量和局部变量区分开
*
* 扩展
* this 关键字其实代表的是“当前对象”
* 记住一句话：通过谁调用的方法，谁就是 this 

* */
public class This_01 {
    String name;//姓名
    public void seeHello(String name){//对方的名字
        System.out.println(name+"你好。我是 "+this.name);
    }
}

package LIANXI.this_01;

public class Main {
    public static void main(String[] args) {
        This_01 n=new This_01();
        //设置自己的名字
        n.name="隔壁老王";
        n.seeHello("老李");
    }
}

===================================================

三、构造方法，就是专门用来创建对象的方法。当通过 new关键字创建对象时，其实就是在调用构造方法；

/*构造方法，就是专门用来创建对象的方法。

当通过 new关键字创建对象时，其实就是在调用构造方法；
*
*如何定义一个构造方法；，格式
* public 构造方法名（参数类型 参数名称）｛
*           方法体
*           //return;//通常最后一行 return省略不写
* ｝
* 调用构造方法的格式  就是创建对象的格式
* new 类名称（）；
 *注意：
 * 1，构造方法不能写返回值类型，连void 都不写
 * 2.构造方法的名称必须和所在的类名称完全一样，大小也要一样。
 * 
 */
public class Person {
            //构造方法
        public Person(){
            System.out.println("构造方法执行！");
        }
}

public class Dem_01 {
    public static void main(String[] args) {
        //创建一个Person类的对象
        Person one=new Person();//可以当做构造方法的名称
    }
}

2、构造方法也是一种方法，所以也可以进行方法重载（Overload）

重载，方法的名称相同，但是参数的列表不同

构造方法重载的好处；

定义一个无参的构造方法，可以直接new对象

定义一个重载的全参数的构造方法，可以再new对象的同时方便对成员变量进行赋值

public class Student {
    private String name;
    private int 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;
    }

    public Student(){
        System.out.println("无参的构造方法执行！");
    }
    public Student(int num){
        System.out.println("有参的构造方法执行！"+num);
        }
        public Student(String name,int age){
            this.age=age;
            this.name=name;
        }
}

public class Main_Student {
    public static void main(String[] args) {
        //调用无参的构造方法来创建对象
        Student one=new Student();
        //调用有参的构造方法来创建对象
        Student two=new Student(19);
        Student stu=new Student();
         stu.setAge(12);
         stu.setName("老王");

        Student xin=new Student("小心",10);
        //直接在new的时候通过构造方法给成员变量赋值
        System.out.println(xin.getName()+xin.getAge());
        //改变成员变量的值
        xin.setName("光头");
        System.out.println("姓名"+xin.getName()+"\t年龄"+stu.getAge());
    }
 }

3、构造方法的时候，注意事项；

       1.构造方法根本不写返回值类型，连void都不写；

        2.构造方法的名称和所在的类名称必须完全一样，大小写也必须一致
        3.构造方法也是可以重载的

        4.构造方法如果没有自定义，将会默认赠送一个。如果自定义了至少一个

         那么就不会再赠送默认的,如果想要就在自定义一个无参的构造方法；

    //如果没有定义任何构造方法，那么编译器将会默认赠送一个无参数。什么都不做的构造方

    法。样子如下

        public  Human(){}

================================================================

四、如何定义一个标准的类（POJO类plain Old Java Object）

        1.所有的成员变量变量需要使用 private 关键自私有

        2.为每一个成员变量编写一对 Gerter  Serter 方法。

        3.编写一个无参数的构造方法

        4.编写一个全参数的构造方法

注意事项：对于所有的数据类型，Getter 都必须叫getXx,Setter 都必须叫SetXxx ，但是有一个特例。

如果是基本数据类型中的Boolean值，那么setXxx规则不变，而getXxx需要写成isXxx的形式；

private Boolean male;

public void setMale(boolean male){

            this.male=male;

            }

练习

定义一个类；代表人，额外具有打招呼功能。根据类创建两个对象并赋值，让两个对象分别和对方打招呼；

package LIANXI.Man;

public class Man_01 {
    private String name;
    private  int age;

    public Man_01() {
    }

    public Man_01(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;
    }
    public void seeHello(String name){
        System.out.println(name+"你好.我是"+this.name+"我今年"+this.age);
    }
}

public class Moden_01 {
    public static void main(String[] args) {
        Man_01 man=new Man_01("亚瑟",23);
        Man_01 man1=new Man_01("后裔",54);
        man.seeHello(man1.getName());
        man1.seeHello(man.getName());
    }
}

====================================================

知识总结

1.面向过程：当需要实现一个功能的时候，每一个过程中的详细步骤和细节都要亲力亲为。

2.面向对象：当需要实现一个功能的时候，不关心详细的步骤细节，而是找人帮我做事；

3：类和对象的关系

        类是抽象的；通常不能直接使用；好像一张装备设计图；

        对象是具体的；根据一个类创建对象使用；也就是根据设计图把装备设计出来；

4，如何定义一个类：成员变量   成员方法

a)成员变量  直接定义在类中，在方法外变；

b）成员方法：去掉 static 关键字，其他的和普通的方法一样；

5.如何根据类创建对象： 格式    类名   对象名  =  new 类名（）；

6.如何使用这个对象

   a） 对象名.成员变量名 

    b)对象名.成员方法（参数）；

7.局部变量和成员变量的不同；

定义位置不同

内存位置不同

生命周期不同

默认值不同

8.private关键字的用法：直接写在成员变量前面，类外面不能直接访问；确保安全性，间接访问

编写一对 Serter  Getter 方法。（特例 如果是Boolean getXxx 必须是isXxx的形式）

9.this关键字的用法      用来区分同名的成员变量的和局部变量  。成员不变量的前面写上 this 即可；

10.构造方法   专门用来创建对象的方法，通过new关键字创建对象就是在调用构造

a)构造方法  不能写返回值类型  void  也不能写

构造方法必须和所在的类名称完全一样，大小写也一样

构造方法也是可以重载的

构造方法如果没有定义，默认送一个，如果定义  就不再赠送