2021-09-04面向对象,封装，Private，this关键字，定义一个类

最新推荐文章于 2022-02-24 18:28:30 发布

WRZLLZ

最新推荐文章于 2022-02-24 18:28:30 发布

阅读量72

点赞数

文章标签：语音识别 java

本文链接：https://blog.csdn.net/weixin_47044513/article/details/120097824

版权

面向过程
当需要实现一个功能的时候，每一个步骤都需要亲历亲为，详细处理每一个细节
面向对象
当需要实现一个功能的时候，不需要关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事。

例：上面为面向过程，下面一行代码为面向对象

	//输出：[10,20,50,60]

import java.util.Arrays;

public class Demo01PrintArray {

    public static void main(String[] args) {
        int [] array={10,20,50,60};
        System.out.print("[");

        for (int i =0; i<array.length;i++){
            if(i==array.length-1){
                System.out.print(array[i] + "]");
            }else {
                System.out.print(array[i] + ",");
            }
        }

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

        System.out.println(Arrays.toString(array));
        //这行代码所表达的与上面所有代码所表达的内容相同

    }
}

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

类和对象

什么是类：是一类相关属性和行为的集合

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

例如：手机设计图为类，那么真正的手机为对象(具体的)

定义一个类，用来模拟"学生"事物。其中就有两个组成部分。
属性(是什么）：
姓名
年龄
行为(能做什么）：
吃饭
睡觉
学习

对应到JAVA中：
成员变量(属性):
String name//姓名
int age //年龄

成员方法(行为):
public void eat(){}//吃饭
public void sleep(){}//睡觉
public void study(){}//学习

注意事项：
1 成员变量是直接定义在类当中的，在方法外
2 成员方法不要写static关键字

例：

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 导包:
指出需要使用的类，在什么位置
import 包名称.类名称；
import cn.itcast.day06.demo01.Student

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

2 创建
类名称对象名 = new 类名称();
Student stu = new Student();

3 使用
使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名(参数)
(也就是想用谁就点谁）

注意事项：
如果成员变量没有进行赋值，那么将会有一个默认值，规则与数组相同

例：

public class Demo02Student {

    public static void main(String[] args) {
        //1.导包
        //我需要使用的Student类，处于同一个包下，所以省略导包语句不写


        //2.创建 格式：
        // 类名称 对象名 = new 类名称();
        // 根据Student类，创建了一个名为stu的对象
        Student stu = new Student();

        //3.使用其中的成员变量，格式：
        // 对象名.成员变量名
        System.out.println(stu.age); //null
        System.out.println(stu.name); // 0


        //改变成员变量中的数值内容
        //将右侧的字符串赋值给左边
        stu.age=28;
        stu.name="w";
        System.out.println(stu.name);
        System.out.println(stu.age);

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

    }

}

因为上面Student的方法不是变量，所以在调用时在小括号里不用写；

若为变量：

public  void  call(String who){
        System.out.println("给" + who +"打电话");
    }

one.call("wei");

wei 就在上方的输出结果里了

局部变量与成员变量的区别：

定义位置不同
局部变量：在方法内部
成员变量：在方法外部，直接写在类当中

2.作用范围不一样
局部变量：只有方法才能使用，出了方法就不能使用
成员变量：整个类全部都可以使用

3 默认值不一样
局部变量：没有默认值，如果想要使用，必须手动进行赋值
成员变量：如果没有赋值，会有默认值，规则与数组相同

4 内存位置不同
局部变量：位于栈内存
成员变量：位于堆内存

5 生命周期不同
局部变量：方法出栈就消失
成员变量：跟着对象，通常不会直接消失

例：

public class VariableDifference {
    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; //局部变量，没有赋值不能用

    }
}

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

封装在JAVA当中的体现：

方法就是一种封装
关键字private也是一种封装

封装就是将一些细节隐藏起来，对外界不可见。
例：

public class Demo02Method {

    public static void main(String[] args) {
        int [] array = {10,20,30};

        int max= getMax(array);
        System.out.println(max);
    }
    
    public static int getMax (int[]array){

        int max = 0;
        for(int i =1; i < array.length; i++){
            if(array[i] > max){
                max = array[i];
            }
        }
        return max;
    }

}

Private

/*问题描述：定义person的年龄时，无法阻止不合理的数值被设计进来
解决方案：使用privat，将需要保护的成员变量进行修饰
一旦使用privat进行修饰，那么本类可以继续访问，但是超出本类不能直接访问
定义一对Getter与Setter方法.

必须叫SetXXX或者getXXX命名规则。
对于Getter来说，不能有参数，返回值类型和成员变量对应。
对于Setter来说，不能有返回值，参数类型与成员变量对应。
*/

public class Person {

    String name;
    private int age;

    public void show() {
        System.out.println("我叫" + name + "年龄" + age);
    }

    public void setAge(int num) { //这个成员方法，专门用于向age设置数据
        if (num >= 0 && num <= 100) {
            age = num;
        }else {
            System.out.println("错误");
        }

    }

    public int getAge() {//这个成员方法，专门获取age数据），没有返回值
        return age;
    }
}

如何调用：
先new 一个新的名字，再需要什么用新的名字点什么
例：

```java
public class Demo03Person {

    public static void main(String[] args) {
        Person person = new Person();
        person.show();


        person.name="w";
        //person.age=18;  若为负数，则不合理，所有要用private,不能直接访问所以错误
        person.setAge(111);
        
        person.show();
    }
}

this关键字

/*
当方法的局部变量和类的成员变量重名时，根据"就近原则"，优先使用局部变量
如果需要访问本类当中的成员变量，需要使用格式
this.成员变量名

"通过谁调用的方法，谁就是this。"
*/

public class Person {

    String name; //我自己的名字

    //参数who是对方的名字
    //成员变量name是自己的名字
    public void sayHello(String who){
        System.out.println(name + "你好，我是" + this.name);
    }
}

**public class Demo01Person {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "w";
        person.sayHello("L");
    }
}**

注意：this是写在sayHello方法中，但是最终由person调用的，所以为person的名字

构造方法

/*
构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法
格式：
public 类名称(参数类型 参数名称){
        方法体
}

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

public class Student {

    //成员变量
    private String name;
    private int age;

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

   //全参构造方法
    public Student(String name,int age){
        System.out.println("全参构造方法执行");
        this.age= age;
        this.name =name;
    }
    //getter 与 setter
    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 class Demo02Student {
    public static void main(String[] args) {
        Student stu1 = new Student();
        Student stu2 = new Student("w",20);
        System.out.println("姓名" + stu2.getName() + "年龄" + stu2.getAge());

        //如果需要改变对象当中的成员变量数据内容，仍然还需要使用setXXX方法

        stu2.setAge(21);
        System.out.println("姓名" + stu2.getName() + "年龄" + stu2.getAge());
    }
}

构造方法可以让程序简便很多

定义一个类：
其实只用成员变量，其他的都可以直接使用工具创建

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 int getAge() {
        return age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

使用：

public class Demo01Student {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setAge(18);
        stu.setName("w");
        System.out.println("我叫" + stu.getName() + "," + "年龄时" + stu.getAge()) ;

        Student stu1 = new Student("L",20);
        System.out.println("我叫" + stu.getName() + "," + "年龄时" + stu.getAge()) ;

        stu.setName("r");
        stu.setAge(21);
        System.out.println("我叫" + stu.getName() + "," + "年龄时" + stu.getAge()) ;

    }
}

WRZLLZ

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2021-09-04面向对象,封装，Private，this关键字，定义一个类

面向过程当需要实现一个功能的时候，每一个步骤都需要亲历亲为，详细处理每一个细节面向对象当需要实现一个功能的时候，不需要关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事。例：上面为面向过程，下面一行代码为面向对象 //输出：[10,20,50,60]import java.util.Arrays;public class Demo01PrintArray { public static void main(String[] args) { int [] ar
复制链接

扫一扫