大数据Java基础DAY8(面向对象——封装)

目录

封装

private关键字

 this关键字

构造方法

给成员变量值的赋值方法

类的成员方法

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

 类的初始化过程

static关键字

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

main方法是静态的


封装

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

好处:

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

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

封装原则:

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

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

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识别

面向对象三大特征——继承icon-default.png?t=M0H8https://blog.csdn.net/qq_52400447/article/details/122546522面向对象三大特征——多态icon-default.png?t=M0H8https://blog.csdn.net/qq_52400447/article/details/122573982

参与评论 您还未登录,请先 登录 后发表或查看评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:游动-白 设计师:我叫白小胖 返回首页

打赏作者

16年义务教育

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值