【JavaEE进阶序列 | 从小白到工程师】JavaEE中的面向对象特征之封装

前言

           本文介绍JavaEE中的面向对象内容，包括什么是对象，怎么创建对象，构造方法使用详情，面向对象的封装特性，成员变量和局部变量的局部，以及this关键字用法，话不多说，直接上代码！！！！💪💪💪
1

一、面向对象是什么？

                   面向对象: 一种编程思想

------------------------------------------------------------------------------------------------------------------------------------------
为什么要学?

         因为这套思想来自生活,生活解决问题,就是一个个的对象在一起打交道,从而将问题解决
         我们写代码的时候,如果也使用这种思想,编程就会更加贴近生活

------------------------------------------------------------------------------------------------------------------------------------------
学什么:
              1.学习自己如何设计对象
              2.学习已有的对象怎么使用
1
2
3
4
5
6
7
8
9
10
11
12

二、类和对象是什么？

1、类和对象

           Java中想要创建对象,必须要先有类的存在
1

2、类的介绍

             什么是类:一组相关属性和行为的集合,将其看做是一张对象的设计图
             
                 
             类的特点: 1、类是对象的数据类型
    
                      2、类是具有相同属性和行为的一组对象的集合
1
2
3
4
5
6

3、类和对象的关系

               *类：是对现实生活中一种具有共同属性和行为的事物的抽象

               *对象：是可以看的到摸得着的真实存在的实体

                                         
               关系: 类是对象的设计图,需要根据类去创建对象
                 
           数量关系:一对多的关系,根据一个类,创建出多个对象                                
    
1
2
3
4
5
6
7
8
9

4、类的组成

      类的组成(属性和行为):
      
               类  --> 设计图 --> 描述一件生活中的事物

                如:
                    学生: class Student{}
                    老师: class Teacher{}
                    手机: class  Phone{}

------------------------------------------------------------------------------------------------------------------------------------------

      类当中写什么?

               属性(名词):
    
                     在代码中使用成员变量表示,成员变量和之前定义的变量一样,只不过位置在方法外
                         如:
                                   public class Phone {   
	                                       String brand;           //方法外面的 成员变量
	                                       int prices;


              行为(动词):
              
                     在代码中使用成员方法表示,成员方法和之前定义的方法一样,只不过不要 "static" 关键字
                         如:
                                      public void call() {        //成员方法
		                                  System.out.println("打电话");
	                                         }
                                       }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

5、对象

🐘创建对象

                 格式:  类名 对象名  = new 类名（）;
                       
                 范例:  Student stu =new Student();
1
2
3

🐘使用对象属性（成员变量）

             格式:    对象名.变量名;
                       
             范例: 会结合打印,赋值使用
                       
                       
        如:
                    
           1.取出成员变量并打印
                     System.out.println(stu.name);  //null   字符串默认null
                     System.out.println(stu.age);   //0      整数默认0

           2.访问成员变量并赋值
                       stu.name="张三";
                       stu.age=20;
                       
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

⭐代码演示

//对象类
public class Student {

//属性:
    String  name;
    int age ;


//行为:
    public  void  study(){
        System.out.println("学生学习...");
    }

    public  void eat(){
        System.out.println("学生吃饭...");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

//测试类
public class StudentTest {

    public static void main(String[] args) {

        Student stu =new Student();


         //对象名.变量名;
        //取出成员变量并打印
        System.out.println(stu.name);  //null   字符串默认null
        System.out.println(stu.age);   //0      整数默认0


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

        //访问成员变量并赋值
        stu.name="张三";
        stu.age=20;

        System.out.println(stu.name);   //张三
        System.out.println(stu.age);    // 20
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

在这里插入图片描述

扩展：打印对象名得到的是全类名

              Student stu =new Student();

              System.out.println(stu);   //Ooptest.Student@b4c966a   全类名@十六进制地址值
              
                                         //@b4c966a这个是这个对象在堆内存当中的内存地址
1
2
3
4
5

在这里插入图片描述

🐘使用对象属性（成员方法）

             格式:对象名.方法名（实际参数）
                         
             范例: 
                         stu.study();          //调用对象中的成员方法
                         stu.eat();
                               

------------------------------------------------------------------------------------------------------------------------------------------                               

 扩展:
      "成员方法的定义格式":
             
        格式:
              public void 方法名(){
                      //方法体
                        }
                               
         范例:
               public void show(){
                   ....
                  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

⭐代码演示1（无参成员方法）

//对象类
public class Student {


//无参成员方法:
    public  void  study(){
        System.out.println("学生学习...");
    }

    public  void eat(){
        System.out.println("学生吃饭...");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

//测试类
public class StudentTest {

    public static void main(String[] args) {

        Student stu =new Student();

      //调用对象中的成员方法
        stu.study();
        stu.eat();

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

在这里插入图片描述

⭐代码演示2（带参成员方法）

//对象类
public class Phone {


//带参成员方法:
    public  void call(String name){
        System.out.println("给"+name+"打电话");
    }

    public  void sendMessage(String name){
        System.out.println("给"+name+"发信息");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

//测试类
public class PhoneTest {

    public static void main(String[] args) {
    
        Phone p= new Phone();
        p.call("张三");
        p.sendMessage("李四");
    }
}
1
2
3
4
5
6
7
8
9
10

在这里插入图片描述

三、权限修饰符

1、权限修饰符介绍

 权限修饰符(成员)

              private: 在同一个类中访问

              default(默认): 在同一个类中,同一个包下

              protected:在同一个类中,同一个包下,不同包的子类

              public:任意位置访问
1
2
3
4
5
6
7
8
9

在这里插入图片描述

2、权限修饰符总结

        * 成员变量一般私有

        * 类、方法、构造器一般公开

        * 如果该成员只希望本类访问，使用private修饰

        * 如果该成员只希望在本包和子类中访问，使用protected修饰
        
        * 如果该成员只希望在本包中访问，使用缺省(默认不写)修饰符

        * 常用的权限修饰符是public和private

         * public通常用于修饰类和方法， private用于修饰成员变量
1
2
3
4
5
6
7
8
9
10
11
12
13

四、成员变量和局部变量的区别

      区别                           成员变量                                 局部变量(不能加修饰符)
           
   类中位置不同                        方法外                                  方法里面
     
   初始化值不同	                   有默认初始化值                  没有默认初始化值，使用前必须完成赋值
      
   内存位置不同                  堆内存(变量在堆内存开空间)        "栈内存" (因为局部变量是在方法里面，而方法是需要被JVM调
                                                                       用，进去栈内存执行的，所以在栈内存里面)     
      
   生命周期不同             随着对象的创建而存在，随着对象的消失而消失     随着方法的调用而存在，随着方法的弹栈而消失

      
    作用域不同                                       都是在自己所在的大括号中
    
    
         例子:
         
              public class Student{                            public void setName(String name){
                         String name;                                       name="张三";
                         int age;                                        }
              }
           
    
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

五、this关键字

1、为什么要使用this？

       当局部变量和成员变量出现了重名问题,Java会根据就近原则,优先使用局部变量

       非要使用成员变量的话,可以使用this关键字进行区分
1
2
3

2、this关键字介绍

             this: 代表当前"类对象"的引用(地址)      //就是当前类对象的地址值
             
                         哪一个对象调用的this，this就代表哪一个对象
                                
   
                                
   如:
       下面的两个this是不一样的:
       
           Phone p1=new Phone();
           System.out.println("打印p1对象名----->"+p1);  //打印p1对象名----->mythis.Phone@34a245ab(这个是p1地址值)
           p1.show();     //this打印出来的也是p1的地址值

           Phone p2=new Phone();
           System.out.println("打印p2对象名----->"+p2);  //打印p2对象名----->mythis.Phone@7cc355be(这个是p2地址值)
           p2.show();    //this打印出来的也是p2的地址值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

⭐代码演示

//对象类
class Phone{
    public  void show(){
        System.out.println(this);
    }
}
1
2
3
4
5
6

//测试类
public class PhoneTest {
    public static void main(String[] args) {

        Phone p1=new Phone();
        System.out.println("打印p1对象名----->"+p1);  //打印p1对象名----->mythis.Phone@34a245ab

        p1.show();


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


        Phone p2=new Phone();
        System.out.println("打印p2对象名----->"+p2);

        p2.show();

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

在这里插入图片描述

六、构造方法

1、什么是构造方法？

       介绍: 构建,创造对象的时候要执行的方法
1

2、构造方法格式

               格式: 
                       1. 方法名与类名相同,大小写也要一致

                       2.没有返回值类型,连void都没有

                       3.没有具体的返回值(不能由retrun带回结果数据)
  
   
例子:
     public Student(){
        System.out.println("这是一个无参构造方法");
              }
           
           
      public  Student(String name,int age){
          this.name=name;  
          this.age=age;
          System.out.println("这是一个带参构造方法");
            }    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3、构造方法执行的时机

   执行时机:  
               1. 在创建对象的时候,被系统自动调用执行
                    
               2. 每创建一次,就会执行一次构造方法

               3. 不能手动调用构造方法
1
2
3
4
5
6

4、构造方法的作用

                    1.本质的作用:用于创建对象
                    
                    2.结合执行时机产生的作用: 可以在创建对象的时候,给成员变量初始化
                    
  如:
        Student stu=new Student("张三",23);   //创建对象的时候,给成员变量初始化
        System.out.println(stu.name+"---"+stu.age);
1
2
3
4
5
6
7

5、构造方法的注意事项


           1. 一个类中如果没有写任何的构造方法,系统将给出一个[默认的][无参数的]构造方法,保证你可以创建对象

           2. 一旦手动给出了构造方法,系统将不会提供默认的构造方法了,这个时候就必须要赋值了

           3.构造方法也是方法，允许重载关系出现

           4.构造方法不允许手动调用,只有在new 对象的时候执行

                           这样子是不行的:  stu.Student();


 // 建议:无参构造方法,和带参数构造方法,都自己手动给出
1
2
3
4
5
6
7
8
9
10
11
12
13

6、无参构造和带参构造方法的使用

                  
            1.无参构造方法创建对象,通过setXxx方法赋值
                    
                 如:
                     StudentTestD  stu =new StudentTestD();
                     stu.setAge(23);
                     stu.setName("张三");
                     stu.show();

------------------------------------------------------------------------------------------------------------------------------------------
                     
            2.带参构造方法创建对象,在创建对象时直接赋值      
            
                如:
                   StudentTestD stu1=new StudentTestD("李四",20);  //输入的顺序和你在构造方法写的顺序一样
                   stu1.show();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

⭐代码演示

//对象类
public class StudentTestD {

    private  String name;

    private  int age;


    public  void show(){

        System.out.println("姓名"+name+",年龄为:"+age);
    }


    public  StudentTestD(){

    }

    public  StudentTestD(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;
    }


}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


public class StudentTestDemo {

    public static void main(String[] args) {

        //1.无参构造方法创建对象,通过setXxx方法赋值
        StudentTestD  stu =new StudentTestD();

        stu.setAge(23);
        stu.setName("张三");
        stu.show();


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


       //2.带参构造方法创建对象,在创建对象时直接赋值
        StudentTestD stu1=new StudentTestD("李四",20);  //输入的顺序和你在构造方法写的顺序一样

        stu1.show();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在这里插入图片描述

7、构造方法生成的快捷键

第一步
在这里插入图片描述

第二步
在这里插入图片描述

第三步
在这里插入图片描述

8、setXxx/getXxx方法生成快捷键

第一步
在这里插入图片描述

第二步
在这里插入图片描述

9、set方法和带参构造方法都可以为成员变量赋值，有什么区别？

               带参构造方法只能在创建对象的时候，完成一次赋值
                      
               set方法可以多次调用，反复去修改对象的属性的值
1
2
3

七、封装

1、什么是封装？

           隐藏实现细节，仅对外暴露公共的访问方式       
1

2、封装在代码中的常见体现

在这里插入图片描述

3、封装小结

       *隐藏实现细节，仅对外暴露公共的访问方式
                          
                将属性抽取到"类"中,这是"对数据"的一种"封装"
                             
                将代码抽取到"方法"中,这是"对代码"功能的一种"封装"    
1
2
3
4
5

4、标准的封装例子

//对象类
public class Student {

    private  int age;

    public void setAge(int age){
        if(age>=0&&age<=100){
            this.age=age;
        }else {
            System.out.println("方法有错");
        }

    }

    public int getAge(){
        return  age;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class StudentTest {
    /*
          标准的JavaBean :

                    1.所有的成员变量 使用 private 修饰

                    2.提供【空参】【带参】构造方法

                    3.针对于私有的成员变量,提供: setXxx \ getXxx方法
                             set: 设置\赋值
                             get: 获取



                    情况: 成员变量,没有进行数据的安全校验
                           有可能记录到一些错误的数据,如负数的年龄

                    解决:
                           1.成员变量私有化
                                错误的数据进不来了,但同时,正确的数据也进不来了

                           2.提供对应的set\get 方法

     */
    public static void main(String[] args) {


        Student stu=new Student();

        stu.setAge(20);

        System.out.println(stu.getAge());

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

在这里插入图片描述

作者：KJ.JK

文章对你有所帮助的话，欢迎给个赞或者 star，你的支持是对作者最大的鼓励，不足之处可以在评论区多多指正，交流学习

相关阅读:
【STM32】IIC的初步使用
 计算机毕业设计（附源码）python影城在线售票及票房数据分析系统
 springboot+高校学生实习档案管理毕业设计-附源码221508
【牛客-剑指offer-数据结构篇】【图解】JZ22 链表中倒数最后k个结点两种方案 Java实现
 PID原理及python简单实现与调参
 Linux 基础-查看进程命令 ps 和 top
深潜Kotlin协程（十六）：Channel
从“交易核心”到“数据核心”，国产数据库要换道超车丨数据猿专访
 CMake 笔记
 TCP的发送系列 — 发送缓存的管理（一）
原文地址：https://blog.csdn.net/m0_47384542/article/details/125376604

【JavaEE进阶序列 | 从小白到工程师】JavaEE中的面向对象特征之封装

目录

前言

一、面向对象是什么？

二、类和对象是什么？

1、类和对象

2、类的介绍

3、类和对象的关系

4、类的组成

5、对象

🐘创建对象

🐘使用对象属性（成员变量）

⭐代码演示

🐘使用对象属性（成员方法）

⭐代码演示1（无参成员方法）

⭐代码演示2（带参成员方法）

三、权限修饰符

1、权限修饰符介绍

2、权限修饰符总结

四、成员变量和局部变量的区别

五、this关键字

1、为什么要使用this？

2、this关键字介绍

⭐代码演示

六、 构造方法

1、什么是构造方法？

2、构造方法格式

3、构造方法执行的时机

4、构造方法的作用

5、构造方法的注意事项

6、无参构造和带参构造方法的使用

⭐代码演示

7、构造方法生成的快捷键

8、setXxx/getXxx方法生成快捷键

9、set方法和带参构造方法都可以为成员变量赋值，有什么区别？

七、封装

1、什么是封装？

2、封装在代码中的常见体现

3、封装小结

4、标准的封装例子

作者：KJ.JK

六、构造方法