面向对象和封装

简介: 面向对象和封装

1、 面向对向的思想


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

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

特点: 面向对象思想是一种符合我们思考习惯的思想,它可以将复杂的事情简单化,并将我们从执行者变成了指挥者。面向对象的语言中,包含了三大基本特征,即封装、继承和多态。


代码示例:



//

import java.util.Arrays;
public class demo01 {
    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("===================");
        //面向对象:找一个jdk给我们提供好的类
        //其中有一个toString方法,直接就能把数组变成想要的格式的字符串
        System.out.println(Arrays.toString(array));
    }
}


2、类和对象


2.1 什么是类


类是一组相关属性和行为的几何。可以看成是一类事物的模板,使用事物的属性特征和行为特征描述该类事物。

属性: 就是该事物的状态信息

行为: 就是该事物能够做什么


2.2 什么是对象


对象是一类事物的具体表现,对象是类的一个实例,必然具备该类事物的属性和行为。


2.3 类与对象的关系


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

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

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


3、 类的定义


3.1事物与类的对比


现实世界的一类事物

属性: 事物的状态信息

行为: 事物能够做什么


java中用class描述事物也是如此:

成员变量: 对应事物的属性

成员方法: 对应事物的行为


类定义的格式:

public class Student {

//成员变量

//成员方法

}


代码示例

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("学习!!");
    }
    }


注意:


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

成员方法不要写static关键字


4、对象的创建及其使用


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


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

import包名称.类名称;

import cn.itcast.demo01.student;

2.对于和当前类属于同一个包的情况省略导包语句不写。

创建,格式:

类名称 对象名=new 类名称();

Student stu=new Student();

3.使用,分为两种情况:

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

使用成员方法:对象名.成员方法名(参数)

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



//

public class student02 {
    public static void main(String[] args) {
        student stu=new student();//与上一段代码的student类一致
        System.out.println(stu.name);//null
        System.out.println(stu.age);//0
        System.out.println("============");
        //改变对象当中的成员变量数值内容
        //将右侧的字符串,赋值交给stu对象当中的name成员变量
        stu.name="王霏霏";
        stu.age=33;
        System.out.println(stu.name);//王霏霏
        System.out.println(stu.age);//33
         System.out.println("============");
        //使用成员方法
        stu.eat();
        stu.sleep();
        stu.study();
    }
}


5、使用对象成为方法的参


定义一个Phone类:


代码示例:



/

public class Phone {
    //成员变量
    String brand;//品牌
    double price;//价格
    String color;//颜色
    //成员方法
    public void call(String who){
        System.out.println("给 " + who +"打电话");
    }
    public void sendMessage(){
        System.out.println("群发短信");
    }
}


public class demo04PhoneParam {
    public static void main(String[] args) {
        Phone one =new Phone();
        one.brand="苹果";
        one.price=8388.0;
        one.color="黑色";
    method(one);
    }
    public static void method(Phone param){
        System.out.println(param.brand);
        System.out.println(param.price);
        System.out.println(param.color);
    }
}


传递过程如下图:

微信图片_20221009105751.png




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


1.定义的位置不一样【重点】

局部变量:在方法的内部

成员变量:在方法的外部,直接写在类中

2.作用范围不一样【重点】

局部变量:只有方法当中才可以使用,出了方法就不能再用了

成员变量:整个类全都可以通用

3.默认值不一样【重点】

局部变量:没有默认值,如果想要使用,必须手动进行赋值

成员变量:如果没有赋值,会有米认知,规则和数组一样

4.内存的位置不一样

局部变量:位于栈内存

成员变量:位于堆内存

5.生命周期不一样

局部变量:随着方法进栈而诞生,随着方法出栈而消失

成员变量:随着对象创建而诞生,随着对象被垃圾回收而消失

代码示例:


public class demo05VariableDifference {
    String name;//成员变量
    public  void  methodA(){
        int num=20;//局部变量
        System.out.println("num");
        System.out.println("name");
    }
    public void methodB(int param){//方法的参数就是局部变量
        //参数在方法调用的时候,必然会被赋值
        System.out.println(param );
        int age;
//        System.out.println(age);//局部变量没赋值不能用
//        System.out.println(num);//错误写法!
        System.out.println(name);
    }
}


7、面向对象三大特征之封装性


面向对象三大特征:封装、寄成、多态


1.封装性在java当中的体现:

方法就是一种封装

关键字private也是一种封装

2.封装就是将一些细节信息隐藏起来,对于外界不可见。


8、构造方法


构造方法是专门用来创建对象的方法,当我们通过关键字new来创建对象时,其实就是在调用构造方法


格式:

public 类名称(参数类型 参数名称){

方法体

注意事项:


  1. 构造方法的名称必须和所在的的类名称完全一样,就连大小写也要一样
  2. 构造方法不要写返回值类型,连void都不要写
  3. 构造方法不能return一个具体的返回值
  4. 如果没有编写任何构造方法,那么编译器将会赠送一个默认方法,没有参数、方法体什么事情都不会做
  5. 一旦编写了至少一个构造方法,那么编译器将不再赠送
  6. 构造方法可以可以进行重载的(重载:方法名称相同,参数列表不同)


9、定义一个标准的类


一个标准的类通常要拥有下面四个组成部分:


  1. 所有的成员变量都要使用private关键字修饰
  2. 为每一个成员变量编写一对Getter/Setter方法
  3. 编写一个全参的构造方法
  4. 编写一个无参的构造方法

这样一个标准的类也叫做java Bean


代码示例:

public class demo06 {
    private String name;
    private  int age;
    public demo06() {  //无参的构造方法
    }
    public demo06(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;
    }
}


/


相关文章
|
4月前
|
存储 开发框架 Java
|
6月前
|
存储 Java 编译器
Java面向对象之——封装
Java面向对象之——封装
|
Java
【Java面向对象】封装的认识与实现
【Java面向对象】封装的认识与实现
86 0
|
6月前
|
数据安全/隐私保护 C++
C++类与对象【封装】
C++类与对象【封装】
|
6月前
|
编译器 C++
[C++] 面向对象的三大特性:封装、继承和多态
[C++] 面向对象的三大特性:封装、继承和多态
80 0
类和对象-封装-封装的意义
类和对象-封装-封装的意义
46 0
|
Java
Java面向对象封装
封装的概念 Java封装是一种面向对象的编程方法,它的主要思想是将类的内部细节(包括数据和方法)隐藏起来,对外只提供公共的访问接口,从而保证了程序的安全性和稳定性。 封装具体实现步骤 1、声明类的成员变量时,使用private关键字进行修饰,将变量设为私有属性(只能在类的内部访问)。 2、为每个私有属性提供getter和setter方法,用来读取和修改私有属性。 3、getter方法用于获取私有属性的值,setter方法用于设置私有属性的值。在方法内部,可以添加一些控制语句用于
74 0
浅谈 面向对象三大特性:封装 继承 多态
浅谈 面向对象三大特性:封装 继承 多态
90 0
|
数据安全/隐私保护 C++
C++类和对象【1】—— 封装
C++类和对象【1】—— 封装
142 0
C++类和对象【1】—— 封装