JAVA面向对象和封装

于 2021-11-10 15:22:01 发布
阅读量682 收藏
点赞数 4
文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_60475929/article/details/121163360
版权

 面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个过程

面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事

面向过程

public class face {
    public static void main(String[] args) {
        int[] array = {10,20,30,40,50};
        //打印格式为[10,20,30,40,50]
        //使用面向过程，每一个步骤亲力亲为
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            if (i == array.length - 1) {
                System.out.println(array[i] + "]");
            }else{
                System.out.print(array[i] + ",");

          }
        }
      
    }
}

 面向对象

import java.util.Arrays;

public class face {
    public static void main(String[] args) {
        int[] array = {10,20,30,40,50};
        //打印格式为[10,20,30,40,50]
        //使用面向过程
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            if (i == array.length - 1) {
                System.out.println(array[i] + "]");
            }else{
                System.out.print(array[i] + " ,");

          }
        }

        System.out.println("=============================");
        System.out.println(Arrays.toString(array));
    //使用面向对象
    //找一个JDK给我们提供好的Arrays类
    //其中有一个toString方法，直接就能把数组变成想要的格式的字符串
    }
}

 面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者。

面向对象的语言中，包含了三大基本特征，即封装，继承和多姿

 类

类：是一组相关属性和行为的集合，可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物

属性：就是该物的状态信息  eg：名字，体重，年龄，颜色

行为：就是该事物能够干什么  eg：走，跑，叫

package javalx;
/*定义一个类，用来模拟“学生事物”，其中就有两个部分组成
属性：（是什么）
        名字
        年龄
行为：吃饭
      睡觉
      学习

对应到JAVA的类当中
成员变量（属性）
  String name;//姓名
  int age;//年龄
成员方法（行为）
    public void eat(){}  //吃饭
    public void sleep(){}  //睡觉
    public void study(){} //学习
 */
public class student {
    String  name;
    int age;
    public void eat(){
        System.out.println("吃饭饭！");
    }
    public void sleep(){
        System.out.println("睡觉觉!");
    }
    public void study(){
        System.out.println("学习！");
    }
}

注意事项

1.成员变量是直接定义在类当中的，在方法外边

2.成员方法没有static关键字

通常情况下，一个类并不能直接使用，需要根据创造一个对象，才能使用

1.导包：也就是指出需要使用的类，在什么位置

import 包名称.类名称   eg：上面代码  import lxjava.student;

对于和当前类属于同一个包的情况，可以省略导包语句不写

2.创建

类名称 对象名 = new 类名称（）；

Student stu = new Student（）；

3.使用 ，分为两种情况

使用成员变量：对象名.成员变量名

使用成员方法：对象名.成员方法名

想用谁，就用对象名点儿谁

类与对象的关系

类是对一类事物的描述，是抽象的

对象是一类事物的实例，是具体的

类是对象的模板，对象是类的实体

package javalx;

public class DemoStudent {
    public static void main(String[] args) {
        
        Student stu = new Student();
        System.out.println(stu.age);//0
        System.out.println(stu.name);//null


         stu.name = "赵丽颖"；
         stu.age = 18;
        System.out.println(stu.age);//18
        System.out.println(stu.name);//赵丽颖
        stu.eat();//吃饭饭！
        stu.study();//学习！


    }
}

注意事项

如果成员变量没有进行赋值，那么将有一个默认值，规则和数组一样

package demo01;
/*属性
品牌，价格，颜色
行为
打电话，发短信
成员变量
String brand;
int prince;
String color;
成员方法
public void call(String who){};
);
public void message(){};
 */

public class Phone {
    String brand;
    int prince;
    String color;
    public void call(String who) {
        System.out.println("给"+who+"打电话");

    }
    public void message(){
        System.out.println("群发短信");
    }
}


package demo01;

public class Demo01Phone {
    public static void main(String[] args) {
        //根据phone类，创建一个名为one的对象
        //格式，类名称 对象名 = new 类名称（）；
        Phone one = new Phone();
        one.brand = "华为";
        one.prince = 9000;
        one.color = "银色";
        System.out.println(one.brand);
        System.out.println(one.prince);
        System.out.println(one.color);
        one.call("任正非");
        one.message();
    }
}

封装

private关键字

是一个权限修饰符

是可以修饰成员（成员变量和成员方法）

作用是保护成员不被别的类使用，被private修饰的成员只在本类中才能访问

针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作

 提供“get变量名（）”方法，由于获取成员变量的值，方法用public修饰

提供“set变量名（参数）”方法，用于设置成员变量的值，方法用public饰

 private关键字的使用

package javalx;
/*定义一个类，用来模拟“学生事物”，其中就有两个部分组成
属性：（是什么）
        名字
        年龄
行为：吃饭
      睡觉
      学习

对应到JAVA的类当中
成员变量（属性）
  String name;//姓名
  int age;//年龄
成员方法（行为）
    public void eat(){}  //吃饭
    public void sleep(){}  //睡觉
    public void study(){} //学习
 */
public class Student {
    String  name;
//    int age;
    private int age;
public void setAge(int a){
    age = a;
}
public int getAge() {
    return age;
}
    public void eat(){
        System.out.println("吃饭饭！");
    }
    public void sleep(){
        System.out.println("睡觉觉!");
    }
    public void study(){
        System.out.println("学习！");
    }
}

package javalx;

public class DemoStudent {
    public static void main(String[] args) {

        Student stu = new Student();
        System.out.println(stu.getAge());
        System.out.println(stu.name);
        stu.name = "刘海洋";
        stu.setAge(30);
        System.out.println(stu.getAge());
        System.out.println(stu.name);
        stu.eat();
        stu.study();
        stu.sleep();
    }
}

this关键字

        this修饰的变量用于指代成员变量

                方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量

                方法的形参没有与成员变量同名，不带this修饰的是成员变量

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

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

package javelx;
public class Student {
    private String  name;
    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    //    int age;
    private int age;
   public void setAge(int a){
      age = a;
}  
    public int getAge() {
       return age;
}
    public void eat(){
        System.out.println("吃饭饭！");
    }
    public void sleep(){
        System.out.println("睡觉觉!");
    }
    public void study(){
        System.out.println("学习！");
    }
}

package javalx;

public class DemoStudent {
    public static void main(String[] args) {

        Student stu = new Student();
        stu.setName("LIUEUX");
        stu.setAge(19);

        System.out.println(stu.getAge());
        System.out.println(stu.getName());
        stu.eat();
        stu.study();
        stu.sleep();
    }
}

封装

1.概述：

是面向对象的三大特征之一（封装，继承，多态）

是面向对象编程语言对客观世界的模拟，客观世界里的成员变量都是隐藏在对象内部的，外界无法操作

2.封装原则

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

成员变量private，提供对应的getXxxv（）/setXxx()方法

3.封装的好处

通过方法来控制成员变量的操作，提高了代码的安全性

把代码用方法进行封装，提高了代码的复用性

构造方法

构造方法概述

        构造方法是一种特殊的方法

        作用：创建对象

        格式：

public  class 类名{                                                public class Student {

        修饰符 类名（参数）{                                           public Student() {

              //构造方法内书写的内容                                     //构造方法内书写的内容

                                }                                                        }

}                                                                                }

  功能：主要完成对象数据的初始化

package demo02;
public class Student{
    private String name;
    private int age;

    public Student() {
        System.out.println("无参构造方法");
    }
    public void show() {
        System.out.println(name+","+age);
    }

注意事项 

标准类的制作

1.成员方法

     使用private修饰

2.构造方法

   提供一个无参构造方法

   提供一个带多个参数的构造方法

3.成员变量

    提供每一个成员变量对应的setXxx（）/getXxx（）

     提供一个显示对象信息的show（）

4.创建对象并为其成员变量赋值的两种方式

        无参构造方法创建对象后使用setXxxv（）赋值

        使用带参数构造方法直接创建带有属性值的对象

public class Student{
   private String name;
   private int age;
    public Student() {}
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
}
    public void setName(String name) {
        this.name = name;
}
    public String getName() {
        return name;
}
    public void setAge(int age) {
      this.age = age;
}
    public int getAge() {
        return age;
}
    public void show() {
        System.out.println(name+","+age);
}
}
package demo02;

public class StudentDemo02 {
    public static void main(String[] args) {
      Student s1 = new Student();
      s1.setName("林青霞");
      s1.setAge(30);
      s1.show();
      Student s2 = new Student("林青霞",30);
      s2.show();
    }
}

面向对像的复习

 类是相同事物共同特征的描述（设计图），对象是具体存在的实例

类中定义5大成分：成员变量，构造器，成员方法，代码块，内部类

 

 构造器

  this关键字

作用：出现在成员方法，构造器中代表当前对象的地址，用于指定访问当前对象的成员变量，成员方法、

 

this在成员变量中的用法

package thisdemo;

public class Car {
    private String name;
    private String price;
    public Car(){}
    public Car(String name, String price) {
        this.name = name;
        this.price = price;
    }
    public void go(String name){
        System.out.println(this);
        System.out.println(this.name+"正在和"+name+"一起比赛！");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPrice() {
        return price;
    }

    public void setPrice(String price) {
        this.price = price;
    }
}

package thisdemo;

import java.util.logging.SocketHandler;

public class test {
    public static void main(String[] args) {
        Car c1 = new Car();
        Car c2 = new Car("法拉利","100亿");

        System.out.println(c2.getName());
        System.out.println(c2.getPrice());
        c2.go("保时捷");
        System.out.println(c2);
    }
}

面向对象的三大特征（封装，继承，多态 ）之一：封装

封装的基本思想:合理隐藏（隐藏细节），合理暴露（提供访问入口)

封装步骤：将成员变量私有，提供方法进行暴露

封装作用：提高业务功能设计的安全性，提高组件化

标准JavaBean 

也可以理解成实体类，其对象可以用于在程序中封装数据

LIUEUX
关注
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值