Java中的对象private关键字this关键字构造方法

Posted 2021-10-26 苦海123

面向对象

概述：Java一种面向对象的程序设计语言，面向对象思想是一种程序设计思想，在面向对象思想的指引下，使用Java语言去设计、开发计算机程序。

这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。

面向对象思想：就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。 它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。

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

面向过程思想：强调完成某件事的具体步骤。

/*
面向过程：当实现一个功能时，每一步都要亲力亲为，详细到每一个细节。
面向对象：当实现一个功能时，不关心具体的步骤，而是找一个可以实现此功能的事物帮助我们完成，这个事物即面向对象。
*/
import java.util.Arrays;
public class Javaobject{
    public static void main(String[] args){
        int[] arr1 = new int[]{1,2,3,4,5};

        // 1.使用面向对象过程打印数组arr1：
        System.out.print("[");//println中ln表示换行，可以去掉ln表示不换行打印
        for(int i = 0; i < arr1.length; i ++){
            if(i < arr1.length - 1){
                System.out.print(arr1[i] + " ,");
            }else{
                System.out.print(arr1[i]);
            }
        };
        System.out.println("]");//[1,2,3,4,5]

        // 2.使用java中内置Arrays.toString()方法实现打印arr1:
        // 找一个JDK给我们提供的Arrays类，Arrays类中有一个toString方法，它可以帮助我们完成这个功能，体现了面向对象的思想。
        System.out.println(Arrays.toString(arr1));//[1, 2, 3, 4, 5],需要注意：使用此方法时，应该导入java中util中的Arrays：import java.util.Arrays;
    }
}

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

属性：某事物的状态信息。

行为：某事物可以做某些事的能力（方法）。

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

类与对象的关系：类是对一类事物的描述，是抽象的，而对象是一类事物的具体实例，是具体的；对象是一个类的具体体现，类是一个对象的模板。

定义类：定义类指的是定义类的成员，其中包括成员变量和成员方法；成员变量是定义在类当中，方法外的变量；成员方法是定义时去掉static(有static为普通方法的定义)。

// 1.定义一个类(学生)：学生类有成员变量（属性）和成员方法（行为）等，如：
public class Students{//public static是固定写法没错，但是在定义类时，这里无需static为成员方法,普通方法才使用static
    // 成员变量：直接定义在类中（方法外）的变量为成员变量
    String name;//名字
    int age;//年龄
    byte sex;//性别
    double weight;//体重
    double height;//体重

    // 成员方法：定义方法时不写static为成员方法，写static为普通方法
    public void sleep(){
        System.out.println("睡觉");
    };
    public void eat(){
        System.out.println("吃饭");
    };
    public void study(){
        System.out.println("学习");
    };
    public void play(String sth){
        System.out.println("玩" + sth);
    };
}

创建对象并使用：
创建对象并使用分三步：

1.导包：指明要使用的类在什么位置，其格式为：import 包名称.类名称；如果类是在当前包中，那么可以不用导包，直接new一个对象。

2.new一个对象：使用关键字new创建某类的实例，其格式为：类名称 对象名（自定义）= new 类名称();

3.使用类成员：使用成员变量其格式为：对象名.成员变量 = 值；使用成员方法其格式为：对象名.成员方法(参数);

// import 包名.Students;// 1.导入包中的某类,顶部导入，这里为同一个包中，可以省略
public class Xiaoming{
    public static void main(String[] args){
        // 2.new一个对象（类的实例）：
        Students xiaoming = new Students();

        // 3. 使用成员变量：
        // 给成员变量赋值：
        xiaoming.name = "小明";
        xiaoming.age = 18;
        xiaoming.sex = 1;
        xiaoming.height = 170;
        xiaoming.weight = 62.5;
        // 打印成员变量的值
        System.out.println(xiaoming.name);//小明
        System.out.println(xiaoming.weight);//62.5
        // 成员方法传参数并调用：
        xiaoming.play("篮球");//玩篮球
        xiaoming.eat();//吃饭
    }
}

一个对象内存图：

两个对象同一类内存图（手机实例做参考）：

两个对象指向同一地址内存图（手机实例做参考）：

对象作为参数传入方法：

// 1.方法中可以传入任何数据类型的数据作为参数，这里将Students类new出来的对象作为参数为例：
public class StudentsParam{
    public static void main(String[] args){
        // 1-1:new两个对象：xiaohong和jack:
        Students xiaohong = new Students();
        xiaohong.name = "小红";
        xiaohong.age = 18;
        xiaohong.sex = 0;
        xiaohong.weight = 50.0;
        xiaohong.height = 170.0;

        Students jack = new Students();
        jack.name = "杰克";
        jack.age = 19;
        jack.sex = 1;
        jack.weight = 60.5;
        jack.height = 170.0;
        // 1-3：分别传入两个对象作为info方法的参数调用info方法：
        info(xiaohong);//当前学生姓名为：小红,龄为：18岁,性别：女,体重为：50.0kg,身高为：170.0cm.
        info(jack);//当前学生姓名为：杰克,龄为：19岁,性别：男,体重为：60.5kg,身高为：170.0cm.
    }
    // 1-2:定义一个普通方法info，要求传入数据类型为Students类的对象做为参数调用(实际传入的是地址值)：
    public static void info(Students someone){//Students类似int等，表示后面somenoe的数据类型，这里为Students类，传入一个对象类型。
        System.out.print("当前学生姓名为："+ someone.name + ",");
        System.out.print("龄为："+ someone.age + "岁,");
        System.out.print("性别："+ (someone.sex == 0 ? "女" : "男") + ",");
        System.out.print("体重为："+ someone.weight + "kg,");
        System.out.println("身高为："+ someone.height + "cm.");
    }
}

对象作为方法返回值：

// 1.将对象作为方法的返回值进行使用：
public class ReturnStudentsobj{
    public static void main(String[] args){
        // 1-2:调用creatStudentInfo方法来创建对象,并将返回值赋值给变量：
        Students stu1 = creatStudentInfo("kuhai",23,(byte) 1,60,167);
        Students stu2 = creatStudentInfo("ConstancyMan",23,(byte) 1,60,167);

        // 1-3:测试通过creatStudentInfo方法返回值创建的对象：
        System.out.println(stu1.name);//kuhai
        System.out.println(stu2.name);//ConstancyMan
    };
    // 1-1：定义个方法creatStudentInfo来创建一个对象并返回这个对象：
    public static Students creatStudentInfo(String names,int ages,byte sexs,double weights,double heights){
        Students stu = new Students();
        stu.name = names;
        stu.age = ages;
        stu.sex = sexs;
        stu.weight = weights;
        stu.height = heights;
        return stu;
    };
};

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

1.定义位置不同：局部变量定义在方法内部；成员变量定义在类中。

2.作用范围（作用域）不同：局部变量只有在方法当中有效；而成员变量在整个类可以使用，包括方法中。

3.默认值不同：局部变量没有默认值；成员变量有默认值。

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

5.生命周期不同：局部变量随着方法进栈产生，方法出栈消失；成员变量随着对象创建产生，对象被垃圾回收成员变量消失。

java中封装：

1.方法即是一种封装。

2.关键字private（私有化）也是一种封装，其是对成员变量的修饰，避免不合理的值被设置给成员变量。被private修饰的成员变量，超出本类后将不能直接访问成员变量，需要通过get-和set-方法间接设置和访问被private修饰的成员变量，如下：

private关键字：

创建类：

// 创建一个PrivatePerson类，并使用private关键字修饰某些成员变量：
public class PrivatePerson{
    String names;
    // 1.使用关键字private修饰某些成员变量，使其在被赋值时可以合法（例如：年龄不能为负值等）
    private int age;
    // int age;

    // 2.在方法info中使用成员变量，包括被private修饰的成员变量（在本类中是可以直接通过点.的方式访问的，一旦超出本类就不能直接访问）
    public void info(){
        System.out.println("该用户的姓名为："+names+",年龄为："+age+"岁。");
    }
    // 3.此时编译此类不会报错，如果不在本类中直接使用age成员变量就会有报错，此时只能间接的访问和设置被private修饰的成员变量：
    // 3-1：设置被private修饰的成员变量其方法是：定义一个方法以参数的形式修改成员变量，在超出类的作用域调用该方法即可，特别强调：方法名应命名为：set+首字母大写的成员变量名，如：setAge
    public void setAge(int ages){
        // age = ages;
        // 4：此时我们可以对传入的参数进行筛选，使其合法，如：
        if(ages < 120 && ages > 0){
            age = ages;
        }else{
            age = 18;
        }
    }
    // 3-2:访问被private修饰的成员变量其方法是：定义一个方法以返回值的形式返回成员变量，在超出本类的作用域调用该方法即可，特别强调：方法名应命名为：get+首字母大写的成员变量名，如：getAge，但是对于布尔类型要命名为is-格式，如：isMan
    public int getAge(){
        return age;
    }
};

实例化对象：

public class NewPersonPrivateage{
    public static void main(String[] args){
        // 1.new一个PrivatePerson类的实例:person1，并使用被private关键字修饰的成员变量age:
        PrivatePerson person1 = new PrivatePerson();
        person1.names = "luck";
        // person1.age = 18;//1-1：通过private关键字修饰的成员变量在超出它自己类后直接使用会报错：错误: age 在 PrivatePerson 中是 private 访问控制
        // 1-2：通过调用实例化对象person1下的setAge和getAge方法设置和访问被private修饰的成员变量：
        // 设置成员变量age:
        person1.setAge(-10);
        // 访问成员变量age:
        int param = person1.getAge();
        System.out.println("person1的名字为："+person1.names+",年龄为："+param+"岁。");//此时不会报错，并打印出了：person1的名字为：luck,年龄为：18岁；这里类似javascript中jsonp跨域请求数据。
    }
}

this关键字：

当方法的局部变量和类的成员变量重名时，根据就近原则使用变量，若要访问成员变量，可以在成员变量前面加this点.如：

//1.创建类：
public class ThisKey{
    String names;
    public void sayHello(String names){
        System.out.println(names+"说："+names+",你好！");//luck说：luck,你好！
        System.out.println(this.names+"说："+names+",你好！");//jack说：luck,你好！
        //this代表当前类，实例化对象后代表实例化的对象
    }
}

//2.实例化对象：
public class ThisKeyObj{
    public static void main(String[] args){
        ThisKey thiskeyobj = new ThisKey();
        thiskeyobj.names = "jack";
        thiskeyobj.sayHello("luck");
        /*
        System.out.println(names+"说："+names+",你好！");//luck说：luck,你好！
        System.out.println(this.names+"说："+names+",你好！");//jack说：luck,你好！
        不使用this方法会使用参数，若使用this方法会使用成员变量！
         */ 
    };
}

构造方法：

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

注意事项：

1.构造方法名称和所在类名称一致

2.构造方法不能写返回值，void也不用写

3.如果没有编写任何构造方法，编译器将自动编译一个构造方法，其什么事也不做。

4,如果自己编写了构造方法，编译器将不再自动编译一个构造方法，使用自己编写的构造方法即可。

5.构造方法也可以重载。

public class Person{
    public Person(){};
}

定义一个标准类：

标准类也叫Java Bean,一个标准的类要满足以下几点：

1.所有成员变量使用private关键字进行修饰。

2.为每一个成员变量编写get-和set-方法。

3.编写一个屋参数的构造方法。

4.编写一个全参数的构造方法。

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

提示：本文图片等素材来源于网络，若有侵权，请发邮件至邮箱：[e-mail]联系笔者删除。
笔者：苦海