面向对象和封装

最新推荐文章于 2024-04-15 20:09:56 发布

weixin_懂否

最新推荐文章于 2024-04-15 20:09:56 发布

阅读量215

点赞数

分类专栏：笔记

本文链接：https://blog.csdn.net/weixin_48064839/article/details/106842940

版权

笔记专栏收录该内容

10 篇文章 0 订阅

订阅专栏

面向对象和封装

面向对象

概念：

1.面向过程：实现一个功能，每一个具体的步骤都要亲历亲为，详细处理每一个细节。

2.面向对象：实现一个功能，不关心具体的步骤，而是找一个具有该功能的人，去帮我做事儿。

代码实现：

package cn.itcast.day06.demo01;

import java.util.Arrays;

public class Demo01PrintArray {
    public static void main(String[] args) {
        //面向过程。
        //打印数组 要求格式为[12,23,34,45,56,67]
        int[] array = {12, 23, 34, 45, 56, 67,99};
        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));
    }
}

面向对象举例

洗衣服

面向过程：手洗
面向对象：全自动洗衣机洗

区别：

面向过程：强调步骤
面向对象：强调结果

特性：

封装性，继承性，多态性

类和对象

什么是类

类：是一组相关属性和行为的集合，可以看做是事物的模板，使用事物的属性特征和行为特征来描述该类事物。
属性：就是该事物的状态特征。
行为：就是该事物能够做什么。

举例：猫

属性：年龄，颜色
行为：跑，跳，吃

什么是对象

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

现实中，一类事物的一个实例。

举例：一只小猫

属性：12， yellow
行为：奔跑，蹦跶，吃猫粮

类和对象的关系

类是对一类事物的描述，是抽象的。
对象是对一个事物的实例，是具体的。
类是对象的模板，对象是类的实体。

类的定义

代码实现：

package cn.itcast.day06.demo01;

/**
 * 定义一个类，用来模拟学生事件，有两个组成部分。
 * 属性（是什么）
 * 姓名
 * 年龄
 * 行为（能做什么）
 * 吃饭
 * 睡觉
 * 对应的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 关键字。

对象的定义及其使用

代码示例：

package cn.itcast.day06.demo01;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

/**
 * 通常情况下，一个类并不能直接使用，只能根据类创建一个对象才能使用。
 * 1.导包：指出需要使用的类，在什么位置。
 * 格式：import 包名称，类名称
 * 对于同一个包下需要使用的类，可以省略导包语句。
 * <p>
 * 2.创建 格式
 * 类名称 对象名 = new 类名称（参数）
 * 3.使用
 * 使用成员变量：对象名。成员变量名。
 * 使用陈冠方法：对象名。成员方法名（）；
 * 注意事项；
 * 如果成员变量没有进行赋值，那么会赋一个默认值，规则和数组一样。
 */
public class Demo02Student {
    public static void main(String[] args) {
        //1、导包 （同一个包下可省略）
        //2.创建
        Student stu = new Student();//类名称 对象名 = new 类名称（参数）
        //使用
        //使用成员变量：对象名。成员变量名。
        System.out.println(stu.age);//0
        System.out.println(stu.name);//nulll
        System.out.println("-------------------");
        stu.age = 10;
        stu.name = "张三";
        System.out.println(stu.age);
        System.out.println(stu.name);
        System.out.println("---------------------");
        //使用陈冠方法：对象名。成员方法名（）；
        stu.eat();
        stu.sleep();
        stu.study();
    }

}

练习：

代码实现：

package cn.itcast.day06.demo02;

/**
 * 定义一个手机类
 * 属性：品牌，价格，颜色
 * 行为：打电话，发短信
 * 成员变量：(属性)
 * String brand;
 * double price;
 * String color;
 * 成员方法：（方法）
 * public void callPhone(){};
 * public void sendMessage(){};
 */
public class Phone {
    String brand;
    double price;
    String color;
    public void callPhone(String who){
        System.out.println("给" + who + "打电话");
    };

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

package cn.itcast.day06.demo02;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

public class Demo01PhoneOne {
    public static void main(String[] args) {
        Phone one = new Phone();
        //成员变量
        one.brand = "华为";
        one.color = "blue";
        one.price = 1000.0;
        System.out.println(one.brand);
        System.out.println(one.color);
        System.out.println(one.price);
        //成员方法
        one.callPhone("乔布斯");
        one.sendMessage();
    }
}

一个对象的内存图

两个对象使用同一个方法的内存

两个引用指向同一个对象

使用对象类型作为方法的参数

代码示例

package cn.itcast.day06.demo02;

public class Demo04PhoneParam {
    public static void main(String[] args) {
      Phone one = new Phone();
      one.price = 1111.0;
      one.color = "black";
      one.brand = "华为";
      method(one);//传递的参数其实就是地址值
    }
    public static void method(Phone param){
        System.out.println(param.price);
        System.out.println(param.color);
        System.out.println(param.brand);

    }
}

l执行流程

注意：当一个对象作为参数传递到方法当中时，实际上传递的是对象的地址值。

使用对象类型作为方法的返回值

代码实现：

package cn.itcast.day06.demo02;

public class Demo05PhoneReturn {
    public static void main(String[] args) {
        Phone two = getPhone();
        System.out.println(two.brand);
        System.out.println(two.color);
        System.out.println(two.price);
    }

    public static Phone getPhone() {
        Phone one = new Phone();
        one.brand = "荣耀";
        one.color = "yellow";
        one.price = 1999.0;
        return one;
    }
}

执行流程：

注意事项：当时用一个对象类型作为方法的返回值时，返回的其实就是对象的地址值。

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

定义的位置不同。

局部变量：在方法的内部。

全局变量：在方法的外部，直接写下类当中。

2.作用范围不一样。

局部变量：只有方法之中才可以使用，出了方法就不能使用。

全局变量：整个类都可以通用。

3、默认值不一样。

局部变量：没有默认值，如果要进行使用，必须手动赋值。

全局变量：如果没有赋值，会有默认值，规则和数组一样。

4.内存的位置不同（了解）

局部变量：位于栈内存。

成员变量：位于堆内存：

4.生命周期不一样（了解）

局部变量：随着方法进栈而诞生，随着方法出栈而消失。

成员变量：随着对象的创建而诞生，随着对象被垃圾回收而消失。

代码示例：

package cn.itcast.day06.demo03;

public class Demo01VariableDefference {
    String name; //成员变量

    public void method() {
       int num = 20;
        System.out.println(name);
        System.out.println(num);
    }
    public void method2(int param){//方法的参数就是局部变量
        //参数在方法调用的时候，必然会被赋值的
        //System.out.println(num);
        System.out.println(name);
    }
}

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

方法就是一种封装。

代码示例

package cn.itcast.day06.demo03;

public class Demo02Method {
    public static void main(String[] args) {
        int[]array = {12,2,34,45,55,66,7,77};
        int max = getMax(array);
        System.out.println(max);
    }
    public static int getMax(int[]array){
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max ){
                max = array[i];
            }
        }
        return max;
    }
}

注意：封装就是讲一些细节信息隐藏起来，对于外界不可见。

关键字private也是一种封装。

代码示例：

package cn.itcast.day06.demo03;

/**
 * 问题描述：定义person的年龄时，无法阻止传入不合理的数据值。
 * 解决方案：用private关键字将需要保护的数据封装起来。
 * 使用private进行修饰后，本类中仍然可以随意访问，但出了本类后不能直接访问。
 * 间接访问必须定义setter和getter方法。
 * 命名规则：
 * 对于getter,不能有参数，返回值类型，和成员变量对应‘
 * 对于setter,不能有返回值，参数类型和成员变量对应。
 */
public class Person {
    private String name;
    private int age;

    public void show() {
        System.out.println("我的姓名" + name + ",年龄" + 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;
    }
}



package cn.itcast.day06.demo03;

public class Demo03Person {
    public static void main(String[] args) {
        Person p = new Person();
        p.setName("张三");
        p.setAge(12);
        p.show();
    }
}

练习

package cn.itcast.day06.demo03;

/**
 * 对于基本类型boolean来说，setter方法规则是isxxx,getter方法无特殊
 */
public class Student {
    private String name;
    private int age;
    private boolean male;

    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;
    }

    public boolean isMale() {
        return male;
    }

    public void setMale(boolean male) {
        this.male = male;
    }
}




package cn.itcast.day06.demo03;

public class Demo04Student {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setAge(10);
        stu.setName("王二");
        stu.setMale(true);
        System.out.println("姓名" + stu.getName());
        System.out.println("年龄" + stu.getAge());
        System.out.println("是否为男性" + stu.isMale());
    }
}

this关键字的作用

package cn.itcast.day06.demo03;

public class Demo04Student {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setAge(10);
        stu.setName("王二");
        stu.setMale(true);
        System.out.println("姓名" + stu.getName());
        System.out.println("年龄" + stu.getAge());
        System.out.println("是否为男性" + stu.isMale());
    }
}


package cn.itcast.day06.demo04;

public class Demo01Person {
    public static void main(String[] args) {
        Person p = new Person();
         p.name = "王健林";
         p.sayHello("王思聪");
        System.out.println(p);
    }
}

注意：通过谁调用的方法，谁就是this.

构造方法

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

2.格式：

public 类名称（参数类型参数名称）{

方法体

}

注意事项：

1.构造方法的名称必须和所在的类名称完全一样。

2.构造方法不要写返回值类型，连void都不要写。

3.构造方法不能return一个具体的返回值。

4.如果没有编写任何构造方法，那么编译器将默认赠送一个构造方法，没有参数，方法体什么事情都不做。

5.一旦编写一个构造方法，那么编译器将不再赠送。

代码示例：

package cn.itcast.day06.demo04;

public class Student {
    //层原变量
    private String name;
    private int age;

    //无参构造方法
    public Student() { //构造方法
        System.out.println("无参构造方法执行了");
    }

    //全参构造方法
    public Student(String name, int age) {
        System.out.println("全参购销方法执行了");
        this.name = name;
        this.age = age;
    }

    //getter setter方法
    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;
    }
}



package cn.itcast.day06.demo04;

public class Demo02Student {
    public static void main(String[] args) {
        Student stu = new Student();
        System.out.println("--------------------");
        Student stu2 = new Student("赵丽颖", 20);
        System.out.println("姓名是" + stu2.getName() + "年龄" + stu2.getAge());
        //如果需要改变成员变量当中的值，那么仍然需要使用setter方法
        stu2.setAge(22);
        System.out.println("姓名是" + stu2.getName() + "年龄" + stu2.getAge());
    }
}

定义一个标准类

代码示例：

package cn.itcast.day06.demo05;

/**
 * 1.所有的成员变量都要用private修饰
 * 2.为每一个成员变量编写setter/getter方法。
 * 3.编写一个无参构造方法。
 * 4.编写一个全参构造方法。
 * 这样的类也叫java Bean
 * 快捷方法 Alt + insert
 * */
public class Student {
    private String name;//姓名
    private int age;//年龄

    public Student() {
    }

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



package cn.itcast.day06.demo05;

public class Demo01Student {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setAge(10);
        stu.setName("迪丽热巴");
        System.out.println("姓名" + stu.getName() + "年龄" + stu.getAge());
        System.out.println("-----------------------------------------");
        Student stu2 = new Student("古力娜扎", 22);
        System.out.println("姓名" + stu2.getName() + "年龄" + stu2.getAge());
        stu2.setAge(25);
        System.out.println("姓名" + stu2.getName() + "年龄" + stu2.getAge());
    }
}

weixin_懂否

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象和封装

面向对象和封装面向对象概念：1.面向过程：实现一个功能，每一个具体的步骤都要亲历亲为，详细处理每一个细节。2.面向对象：实现一个功能，不关心具体的步骤，而是找一个具有该功能的人，去帮我做事儿。代码实现：package cn.itcast.day06.demo01;import java.util.Arrays;public class Demo01PrintArray { public static void main(String[] args) { //面向过
复制链接

扫一扫