大数据Java基础DAY8（面向对象——封装）

封装

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

好处：

           隐藏实现细节，提供公共的访问方式

           提高了代码的复用性 提高安全性。

封装原则：

            将不需要对外提供的内容都隐藏起来。

             把属性隐藏，提供公共方法对其访问。

private关键字

private关键字：是一个权限修饰符。

                     可以修饰成员(成员变量和成员方法).

                     被private修饰的成员只在本类中才能访问。

private最常见的应用： 把成员变量用private修饰

                                 提供对应的getXxx()/setXxx()方法

                                  一个标准的案例的使用

class Phone{  //定义一个手机类
    private String name;  //用private修饰成员变量
    private int price;
    private String color;
    //提供一个公共的set方法，使外界能给成员变量赋值
    public void setName(String s) {
      name = s;
    }
    //提供一个公共的get方法，使外界能能获取到成员变量的值
    public String getName() {
        return name;
    }
    public void setPrice(int p){
        price= p;
    }
    public int getPrice(){
        return price;
    }
    public void setColor(String c){
        color=c;
    }
    public String getColor(){
        return color;
    }
    public void show(){//打印所有的成员变量值
        System.out.println("品牌："+name+" 价格:"+price+" 颜色:"+color);
    }
}
public class PrivateTest1 {
    public static void main(String[] args) {
           Phone r=new Phone();
       //调用set方法为成员变量赋值
           r.setName("XX手机");
           r.setPrice(9999);
           r.setColor("黑色");
           r.show();
           //调用get方法获取成员变量的值
        System.out.println(r.getName());
        System.out.println(r.getPrice());
        System.out.println(r.getColor());
    }
}

this关键字

this:代表所在类的对象引用

记住： 方法被哪个对象调用，this就代表那个对象

class Dog{//定义一个狗的类
    //定义狗的成员变量（品种，名字，年龄）
    private String breed;
    private String name;
    private int age;

    public void setBreed(String breed) {
        this.breed = breed;   //使用this引用对象
    }
    public void setName(String name) {
        this.name = name; //这里其实隐藏了一个this，可以不写，因为就近原则就是对象的成员变量
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getBreed() {
        return breed;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public void show(){
        System.out.println("品种："+breed+"名字："+name+"年龄："+age);
    }
}
public class PrivateTest3 {
    public static void main(String[] args) {
        Dog dog=new Dog(); //创建一个狗的对象
        //给成员变量进行赋值
        dog.setBreed("哈士奇");
        dog.setName("大风");
        dog.setAge(4);
        dog.show();
    }
}

构造方法

构造方法作用概述：给对象的数据进行初始化

构造方法格式

                  方法名与类名相同

                  没有返回值类型，连void都没有

                  没有具体的返回值

无参构造方法：

class Student{  //定义一个学生类
    //定义成员变量
    private String name;
    private int age;

    //定义一个构造方法
    Student(){
        System.out.println("这是一个构造方法");
    }

}
public class StudentTest {
    public static void main(String[] args) {
        //创建Student类的对象
        //调用的是无参构造方法创建对象
        Student student=new Student();
    }
}

** 带参构造方法：**

class Student{  //定义一个学生类
    //定义成员变量
    private String name;
    private int age;

    //定义一个无参构造方法
    Student(){
        System.out.println("这是一个构造方法");
    }

    //定义一个带参数name的构造方法
    Student(String name){
        System.out.println("这是一个带参数name的构造方法");
    }

    //定义一个带参数name和age的构造方法
    Student(String name,int age){
        System.out.println("这是一个带参数name和age的构造方法");
        this.name=name;
        this.age=age;
    }
    public void show(){
        System.out.println(name+"------"+age);
    }

}
public class StudentTest {
    public static void main(String[] args) {
        //创建Student类的对象
        //调用的是无参构造方法创建对象
        Student student=new Student();
             student.show();
        //使用带一个参数的构造方法创建对象
        Student student1=new Student("小米");
              student1.show();
        //使用带两个参数的构造方法创建对象     
        Student student2=new Student("小明",18);
             student2.show();
    }
}

构造方法注意事项

                   如果你不提供构造方法，系统会给出默认构造方法

                   如果你提供了构造方法，系统将不再提供

                   构造方法也是可以重载的

给成员变量值的赋值方法

a.使用无参构造方法+setXxx()方法给成员变量赋值

b.使用带参数的方法给成员变量赋值，需要与this关键字配合使用。

类的成员方法

方法具体划分：

     a.**根据返回值**：有明确返回值的方法

                              返回void类型的方法（无返回值）

      b.**根据形式参数：**无参方法

                                  有参方法

class Function{
    //定义一个无返回值无参数的方法
    public void Function1(){
        System.out.println("这是一个无返回值无参数的方法");
    }
    //定义一个无返回值有参数的方法
    public void Function2(String name){
        System.out.println("这是一个无返回值有参数的方法"+name);
    }
    //定义一个有返回值无参数的方法
      public String Function3(){
        return "16年义务教育";
    }
    //定义一个有返回值有参数的方
    public  String Function4(String s){
        return s+"欢迎你";
    }
}
public class FunctionTest {
    public static void main(String[] args) {
        Function function=new Function();//创建function类的对象
       //无返回值的方法，直接调用输出结果
        function.Function1();
        function.Function2("User");
        
       //有返回值的方法，调用时，需要用一个变量接收
        String s= function.Function3();
        System.out.println(s);

        String e= function.Function4("User");
        System.out.println(e);
    }
}

一个基本类的标准代码写法

类的组成：成员变量，成员方法

成员变量：被private修饰

构造方法：一个无参构造方法/一个带所有参数的构造方法

成员方法：setXxx（...）和getXxx()

show()：打印所有成员变量的值

例：一个手机的标准代码

class Phone{
    //定义成员变量
    private String brand;
    private int price;
    private String color;
    //定义构造方法（快捷键alt +insert选Constructor）
    public Phone() {}

    public Phone(String brand, int price, String color) {
        this.brand = brand;
        this.price = price;
        this.color = color;
    }
    //setXxx()方法和getXxx方法（快捷键alt+insert选Getter和Setter）
    public String getBrand() {
        return brand;
    }
    public int getPrice() {
        return price;
    }
    public String getColor() {
        return color;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    public void setColor(String color) {
        this.color = color;
    }
    //定义一个打电话的方法
    public void call(String name){
        System.out.println("给"+name+"打电话");
    }
    //展示所有成员变量的值
    public void show(){
        System.out.println("品牌："+brand+",价格："+price+",颜色："+color);
    }
}
public class PhoneTest {
    public static void main(String[] args) {
        Phone phone=new Phone("华为",9999,"黑色");//调用有参构造方法创建对象
        phone.show();
        phone.call("User"); //调用打电话的方法
    }
}

类的初始化过程

Student s = new Student();在内存中做了哪些事情?

a.加载Student.class文件进内存

b.在栈内存为s开辟空间

c.在堆内存为学生对象开辟空间

d.对学生对象的成员变量进行默认初始化

e.对学生对象的成员变量进行显示初始化

f.通过构造方法对学生对象的成员变量赋值

g.学生对象初始化完毕，把对象地址赋值给s变量

static关键字

可以修饰成员变量和成员方法

**static关键字特点 :**随着类的加载而加载

                          优先于对象存在

                          被类的所有对象共享(这也是我们判断是否使用静态关键字的条件)

                          可以通过类名调用

例：我们创建一个动物类

class Animal{  //定义一个动物类
    private String name;
    private String color;
    private String kind;

    public Animal(){}

    public Animal(String name, String color, String kind) {
        this.name = name;
        this.color = color;
        this.kind = kind;
    }
     //getXxx()和setXxx(..)方法

    public void show(){
        System.out.println("动物名字："+name+",颜色:"+color+",种类:"+kind);
    }
}
public class AnimalTest {
    public static void main(String[] args) {
           Animal animal=new Animal("老虎","黄色","猫科动物");//用构造方法创建Animal类的对象
                         animal.show();
           Animal animal1=new Animal("狮子","棕色","猫科动物");
                         animal1.show();
           Animal animal2=new Animal("猫","白色","猫科动物");
                         animal2.show();
    }
}

我们可以发现这三种动物都是猫科动物，每次创建新对象时，就会在堆内存中开辟空间，如果数量非常多，这样就造成了浪费，所有我们可以用static改进。

改进后：

class Animal{  //定义一个动物类
    private String name;
    private String color;
    private static String kind;  //使用static修饰kind

    public Animal(){}

    public Animal(String name, String color, String kind) {
        this.name = name;
        this.color = color;
        this.kind = kind;
    }
    public Animal(String name,String color){  //新增构造方法
        this.name = name;
        this.color = color;
    }
     //getXxx()和setXxx(..)方法

    public void show(){
        System.out.println("动物名字："+name+",颜色:"+color+",种类:"+kind);
    }
}
public class AnimalTest {
    public static void main(String[] args) {
           Animal animal=new Animal("老虎","黄色","猫科动物");//用构造方法创建Animal类的对象
                         animal.show();
           Animal animal1=new Animal("狮子","棕色"); //调用新的构造方法
                         animal1.show();
           Animal animal2=new Animal("猫","白色");
                         animal2.show();
    }
}

改进前后的输出结果都是一样的，改进后的更加节省内存

static关键字注意事项 : 在静态方法中是没有this关键字的

                                   静态方法只能访问静态的成员变量和静态的成员方法

静态变量和成员变量的区别

a.所属不同：

** **静态变量属于类，所以也称为为类变量

          成员变量属于对象，所以也称为实例变量(对象变量)

b.内存中位置不同

          静态变量存储于方法区的静态区

          成员变量存储于堆内存

c.内存出现时间不同

          静态变量随着类的加载而加载，随着类的消失而消失

          成员变量随着对象的创建而存在，随着对象的消失而消失

d.调用不同

           静态变量可以通过类名调用，也可以通过对象调用

           成员变量只能通过对象名调用

main方法是静态的

public static void main(String[] args) {}

a. public 被jvm调用，访问权限足够大。

b. static 被jvm调用，不用创建对象，直接类名访问

c.void被jvm调用，不需要给jvm返回值

d. main 一个通用的名称，虽然不是关键字，但是被jvm识别