面向对象（二）

一、封装的概述
1.定义一个学生类：
成员变量：name,age;
成员方法：show()方法。

我们在使用这个案例的过程中发现了一个问题。    通过对象去给成员变量赋值，可以赋值一些非法的数据。    这是不合理的。    应该是这个样子的，在赋值之前，先对数据进行判断。    判断到底在哪里做比较合适呢？    StudentDemo类是一个测试类，测试类一般只创建对象，调用方法。    所以，这个判断应该定义在Student类中。    而我们在成员变量的位置可不可以进行 数据判断呢？    是不可以的，因为做数据校验必须要依靠一些逻辑语句。    逻辑语句是应该定义在方法中，所以，我们最终决定在Student类中提供一个方法按照我们前面的分析，我们给出了一个方法进行校验但是呢，它偏偏不调用方法来赋值，还是直接赋值了，这样我们的方法就没有起到作用。我就应该要求你必须使用我的方法，而不能直接调用成员变量赋值。怎么去强制要求不能直接使用成员变量呢？    针对这种情况，java就提供了一个关键字private        private：私有的，可以修饰成员变量和成员方法。        注意：被private修饰的成员只能在本类中访问。    其实讲到现在讲解的是一个封装的思想。        封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

class Student{    //姓名    String name;    //年龄     private int age;    //写一个方法对数据进行校验    /*        返回值类型：void        参数列表：int a    */    public void setAge(int a){        if(a < 0 || a > 120){            System.out.println("年龄有问题！");        }else{            age = a;        }    }    //show()方法，显示所有成员变量值    public void show(){        System.out.println("姓名："+name);        System.out.println("年龄："+age);    }}class StudentDemo{    public static void main(String[] args){        Student s = new Student();        s.show();        System.out.println("-----------");        s.name = "XXX";        //s.age = 20;        s.setAge(20);        s.show();        System.out.println("-----------");        //给age赋值        //s.age = -21;//这个数据是不合理的。        s.setAge(-20);        s.show();        System.out.println("-----------");    }}

2.封装的好处：
隐藏实现细节，提供公共的访问方式
提高了代码的复用性。
提高了安全性。
封装的原则：
把不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
3.private的特点
记住：凡是不需要被外界访问的成员，都可以设置成private
private：
是一个权限修饰符
可以修饰成员变量和成员方法，外界不能直接访问
被其修饰的成员只能在本类中被访问。

class Demo{    //int num = 10;    //用private修饰    private int num = 10;    public void show(){        System.out.println(num);    }    private void method(){        System.out.println("method");    }//如果想要在外界直接调用这个方法，是调用不了的，    //需要向外界提供一个公共的访问窗口    public void function(){        method();    }}class PrivateDemo{    public static void main(String[] args){        Demo d = new Demo();        //System.out.println(d.num);        d.show();        //不能访问私有的成员方法        //d.method();//错误: method()可以在Demo中访问private        d.function();    }}

4.private的应用
封装和private的应用
A：把成员变量用private修饰
B：提高对应的getxxx()和setxxx()方法。
**对外提供一个给成员变量赋值和获取值的方法。

class Student{    //姓名    private String name;    //年龄    private int age;    //给姓名赋值    public void setName(String n){        name = n;    }    //获取姓名值    public String getName(){        return name;    }    //给年龄赋值    public void setAge(int a){        age = a;    }    //获取年龄的值    public int getAge(){        return age;    }}//测试类class PrivateDemo2{    public static void main(String[] args){        //创建学生对象        Student s = new Student();        //使用成员变量        //错误：被私有修饰了，外界不能直接访问了。        //System.out.println(s.name+"---"+s.age);        System.out.println(s.getName()+"----"+s.getAge());        //给成员变量赋值        //通过方法赋值        s.setName("XXX");        s.setAge(27);        System.out.println(s.getName()+"----"+s.getAge());    }}

标准类的代码是不需要做数据校验的，数据校验可以放在浏览器中来校验。

二、this关键字的概述和应用
起名字要做到见名知义。

this：是当前类的对象引用。简单的记，它就代表当前类的一个对象。    注意：谁调用这个方法，在该方法内部的this就代表谁。this的场景：    解决局部变量隐藏成员变量

class Student{    //姓名    private String name;    //年龄    private int age;    //给姓名赋值    public void setName(String name){    // name = name;//变量的使用规则：就近原则。    //这里是类名，目前还没有说过类似的用法，所以这个是有问题的。    //这里的调用只能通过对象名    //这个对象如果存在，它应该代表的是Student的一个对象    //那么，谁能够代表当前类的对象呢？java提供了一个关键字：this    this.name = name;    }    //获取姓名值    public String getName(){        return name;    }    //给年龄赋值    public void setAge(int age){        this.age = age;    }    //获取年龄的值    public int getAge(){        return age;    }}class ThisDemo{    public static void main(String[] args){        //创建学生对象        Student s = new Student();        s.setName("XXX");        s.setAge(21);        System.out.println(s.getName()+"----"+s.getAge());    }}

this:哪个对象调用那个方法，this就代表那个谁

class Student{    private String name;    private int age;    public void setName(String name){         this.name = name;    }    public String getName(){        return name;//这里其实是隐含了this    }    public void setAge(int age){        this.age = age;    }    public int getAge(){        return age;    }}class StudentDemo{    public static void main(String[] args){        //创建一个对象        Student s = new Student();        s.setName("周秀蓉");        s.setAge(27);        System.out.println(s.getName()+"----"+s.getAge());        //创建第二个对象        Student ss = new Student();        ss.setName("杨斌");        ss.setAge(30);        System.out.println(ss.getName()+"----"+ss.getAge());    }}

标准手机类及其测试
手机类：
成员变量：
品牌
价格
颜色
成员方法：
针对每一个成员变量给出对应的getxxx()方法和setxxx()方法
最后定义测试：
创建一个对象，先通过getxxx()方法输出成员变量的值。
这一次的结果是：null—0—null
然后通过setxxx()方法给成员变量赋值。再次输出结果。这一次的结果是：
三星—3999—土豪金

class Phone{    //品牌    private String brand;    //价格    private int price;    //颜色    private String color;    //getxxx()和setxxx()方法    public void setBrand(String brand){        this.brand = brand;    }    public String getBrand(){        return brand;    }    public void setPrice(int price){        this.price = price;    }    public int getPrice(){        return price;    }    public void setColor(String color){        this.color = color;    }    public String getColor(){        return color;    }}class PhoneTest{    public static void main(String[] args){        //创建手机对象        Phone p = new Phone();        //直接输出默认值        System.out.println(p.getBrand()+"----"+p.getPrice()+"----"+p.getColor());        //给成员变量赋值        p.setBrand("三星");        p.setPrice(3999);        p.setColor("土豪金");        //再次输出        System.out.println(p.getBrand()+"----"+p.getPrice()+"----"+p.getColor());    }}

三、构造方法
1.给对象的数据进行初始化
格式：
A：方法名与类名相同
B：方法没有返回值类型，连void都没有
C：没有具体的返回值。

class Student{    private String name;//null    private int age;//0    public Student(){        System.out.println("这是构造方法！");    }}class ConstructDemo{    public static void main(String[] args){        //创建对象        Student s = new Student();        System.out.println(s);//Student@77ec3adc    }}

2.我们一直在使用构造方法，但是，我们确没有定义构造方法，用的是哪里来得呢？

    构造方法的注意事项：        A：如果我们没有给出构造方法，系统将自动提供一个无参构造方法。        B：如果我们给出了构造方法，系统将不再提供默认的无参构造方法。            注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法    给成员变量赋值有两种方式：        A：setxxx()方法        B：构造方法

class Student{    private String name;    private int age;    public Student(){        System.out.println("我给了无参构造方法，你还给不？");    }    //构造方法的重载格式    public Student(String name){        System.out.println("这是一个带String类型的构造方法");        this.name = name;    }    public Student(int age){        System.out.println("这是一个带int类型的构造方法");        this.age = age;    }    public Student(String name, int age){        System.out.println("这是一个带多个类型的构造方法");        this.name = name;        this.age = age;    }    //向外提供一个公共的方法。    public void show(){        System.out.println(name+"-----"+age);    }}class ConstructDemo2{    public static void main(String[] args){        //创建对象        Student s = new Student();        System.out.println("---------");        //创建对象2        Student s2 = new Student("XXX");        s2.show();        //创建对象3        Student s3 = new Student(21);        s3.show();        //创建对象4        Student s4 = new Student("XXX",21);        s4.show();    }}

四、成员方法以及构造方法
类的组成：成员变量，成员方法
今天我们又加入了一个新的成员：构造方法
以后类的组成：
成员变量
构造方法
成员方法
根据返回值：
void类型
非void类型
根据形式参数：
空参方法
非空参方法

class Student{    //带明确返回值的    public String getString(){        return "hello";    }    //没有返回值的，void类型    public void show(){        System.out.println("show");    }    //带参数没有返回值    public void method(String name){        System.out.println(name);    }    //带参数有返回值    public String function(String s1, String s2){        return s1+s2;    }}class StudentDemo{    public static void main(String[] args){        //创建对象        Student s = new Student();        //调用无返回值类型方法        s.show();        //调用有返回值类型方法        String result = s.getString();        System.out.println(result);        //调用带参无返回值类型的方法        s.method("XXX");        //调用带参数有返回值类型的方法        String result2 = s.function("XXX","和YYY");        System.out.println(result2);    }}

五、创建对象做了哪些事情

六、什么时候定义成员变量
定义一个类Demo,其中定义一个求两个数据和的方法，
定义一个测试类Test，进行测试。

变量什么时候定义成成员变量：    如果这个变量是用来描述这个类的信息的，那么，    该变量就应该定义为成员变量    变量到底定义在哪里好呢？    变量的范围是越小越好，因为能及时的被回收。