Java开发Day11

最新推荐文章于 2023-01-23 15:03:43 发布

Madelana

最新推荐文章于 2023-01-23 15:03:43 发布

阅读量210

点赞数

文章标签： java

本文链接：https://blog.csdn.net/madelana/article/details/104906398

版权

《类与对象、封装、构造方法》

面向对象思想

一、概述

面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节
面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事儿
区别：（以洗衣服为例）
（1)面向过程：强调步骤，这里指的是自己洗衣服的一个挨着一个的步骤
（2）面向对象：强调对象，这里的对象就是洗衣机
特点：面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者。面向对象的语言中，包含了三大基本特征，即封装、继承和多态

类与对象

一、定义

什么是类
（1）类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。
现实中，描述一类事物：
属性：就是该事物的状态信息
行为：就是该事物能够做什么
什么是对象
（1）对象：是一类事物的具体表现。对象是类的一个实例，必然具备该类事物的属性和行为
类与对象的关系

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

类的定义
（1）事物与类的对比

现实世界的一类事物：
属性：事物的状态信息
行为：事物能够做什么
Java中用class描述事物也是如此：
成员属性：对应事物的属性
成员方法：对应事物的行为
类的定义格式

public class ClassName {
//成员变量
//成员方法
}

定义类：就是定义类的成员，包括成员变量和成员方法

成员变量：和以前定义变量几乎是一样的。只不过位置上发生了改变。成员变量要定义在类当中，是在方法外面的

public class Student{
/**
*定义成员变量（属性）
*/
int age; //学生年龄
String name; //学生姓名
int grade; //学生年级
String sex; //学生性别
}

成员方法：和以前定义方法几乎是一样的。只不过把static去掉，static的作用在后面的文章中再详细讲解

public class Student{
//定义成员变量（属性）
int age;
int grade;
String name;
String sex;
/**
*定义成员方法（行为），下面定义的方法都是不需要返回值、不需要参数的
*/
public void eat(){ //吃饭
	system.out.println("真香");
public void sleep()} //睡觉
	System.out.println("我在睡觉");
}
}
}

二、使用类

使用类：通常情况下，一个类并不能直接使用，需要根据类创建一个对象才能使用
使用前准备功作

[1] 导包：就是指出需要使用的类在什么位置

import 包名称.类名称;

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

[2] 创建对象：

类名称 对象名 = new 类名称();
/**
*创建一个stu对象
*/
Student stu = new Student();

正式使用类
我们可以回顾一下，在我们创建一个类时，在定义的类中创建了这个类的属性和行为（用术语，即成员变量和成员方法），而现在我们新定义了一个对象用来实现对类的调用，而对象是类的具体实例，因此这个新建的对象具有这个类所具有的一切，因此，这个类也有属性和行为，即变量和方法。因此，在使用我们新定义的对象时，我们可以使用它所具有的属性和方法。

[1] 使用成员变量：对象名.成员变量名

/**
*使用成员变量并对其初始化
*/
stu.name ="Javaer";
sut.age = 18;

-[2] 使用成员方法：对象名.成员方法名（参数）

stu.sleep();
stu.eat();
stu.study();

`也就是想用谁，就用对象名点谁
注意事项：如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样

使用类总结：
（1）导包 import 包名.类名;

如果需要使用的类和当前类属于同一个包，可以省略导包语句不写

（2）创建对象 类名对象名 = new 类名;
（3）使用

使用成员变量 对象名.成员变量名;
使用成员方法 对象名.成员方法名(参数);

示例：定义一个类，用来模拟手机事物
分析：
属性：品牌、价格、颜色
行为：打电话、发短信

对应到类当中：
成员变量（属性）：
String brand; //品牌
double price; //价格
String color; //颜色
成员方法（行为）：
public void call(String who){} //打电话
public void sendMessage() {} //群发短信

public class Phone {
    /**
     * 成员变量
     * String brand;品牌
     * double price;价格
     * String color;颜色
     */

    String brand;
    double price;
    String color;

    /**
     * 成员方法
     * public void call(String who){} 打电话
     * public void sendMessage(){} 群发短信
     */

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

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

    public static void main(String[] args) {
        //根据Phone类创建一个名为one的对象
        Phone one = new Phone();
        System.out.println(one.brand); //null
        System.out.println(one.color); //null
        System.out.println(one.price); //0.0

        one.price = 8383;
        one.color = "red";
        one.brand = "大禹";
        System.out.println(one.price);
        System.out.println(one.color);
        System.out.println(one.brand);

        one.call("张三");
        one.sendMessage();

    }
}

三、类与对象的内存

一个对象的内存图
两个对象使用同一个方法的内存
两个引用指向同一个对象的内存图
使用对象类型作为方法的参数的内存图
使用对象类型作为方法的返回值

四、局部变量和成员变量的不同

定义位置不同（重点）

局部变量定义在方法内部
成员变量定义在类中、方法外部

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

	public void methodA(){
		int num = 20; //局部变量
	}
}

作用范围不一样（重点）

局部变量只用在特定的方法中才能使用，出了该方法就不能使用了
成员变量：整个类中全都可以使用

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

	public void methodA(){
		int num = 20; //局部变量
		System.out.println(num); //打印20
	}
	public void methodB(){
		System.out.println(num);//错误写法
		System.out.println(name);//打印名字
	}
}

默认值不一样（重点）

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

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

	public void methodA(){
		int num = 20; //局部变量
		System.out.println(num); //打印20
		System.out.println(name); //打印默认值null
	}
	public void methodB(){
		int age;
		System.out.println(age); //错误写法，因为age没有初始化
		System.out.println(num);//错误写法，超出局部变量的作用域
		System.out.println(name); //打印默认值null
	}
}

内存位置不一样（了解）

局部变量：位于栈内存中
成员变量：位于堆内存中

生命周期不同（了解）

局部变量：随着方法进栈而诞生，随着方法出栈而消失
成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失

五、面向对象的三大特性之封装性

封装性在Java代码当中的体现：

方法就是一种封装
关键字private（私有化）也是一种封装
封装就是将一些细节信息隐藏起来，对于外界不可见
1.1 private的使用：在定义Person的年龄时，无法阻止不合理的数值被设置进来（例如：-21）。解决方案：使用private关键字将需要保护的变量进行修饰。一旦使用了private修饰符，那么本类当中仍然可以随意访问，但是，超出了本类范围之外就不能再直接访问了。但是可以间接访问private成员变量，就是定义一对Getter/Setter方法（倒手）

public class Person{
	String name; //姓名
	private int age; //年龄

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

//这个成员方法，专门用于向age设置数据
	public void setAge(int num){
		if(num < 100&& num>=9){//如果传入的数据是合理情况
			age = num;
		}else{
		System.out.println("数据不合理!");
	}
}

//这个方法专门用于获取age的数据
	public int getAge(){
	return age;
	}
}
/**
*下面的main方法和Person不在同一个类中，但是在同一个包中，所以不需要写导包语句
*/	
	public static void main(String[] args) {
	Person person = new Person();
	Person.show(); //打印出age的默认值：0

	person.name="张三";
	person.age = -20; //直接访问private内容，错误写法
/**
*间接访问age
*/
	Person.setAge(20);//age = 20
	Person.steAge(-20); //输出数据不合理！
	Person.show();//输出赋值后的语句
}

总结：
必须是steXXX; getXXX
对于基本类型中的boolean类型值，Getter方法一定要写成isXXX格式，而setXXX规则不变
对于Getter来说，不能有参数，返回值类型要和成员变量对应
对于Setter来说，不能有返回值，参数类型要和成员变量对应

练习：用private关键字写一个学生类

public class student {
    private String name; //姓名
    private int age; //年龄
    private boolean male; //是否为男性

    public void setName(String str){ //设置姓名
        name = str;
    }

    public String getName(){ //获取姓名
        return name;
    }

    public void setAge(int num){ //设置年龄
        if(num<100&&num>0) {
            age = num;
        }
        else{
            System.out.println("数据不合理！！!");
        }
    }

    public int getAge(){ //获取年龄
        return age;
    }

    public void setMale(boolean b){ //设置性别
        male = b;
    }

    public boolean isMale(){ //获取性别
        return male;
    }


    public static void main(String[] args) {
        student stu = new student(); //定义对象以使用类
/**
*使用成员方法
*/
        stu.setName("鹿晗");
        stu.setAge(20);
        stu.setMale(true);

        System.out.println("姓名："+stu.getName());
        System.out.println("年龄："+stu.getAge());
        System.out.println("是否为男性："+stu.isMale());
    }
}

五、this关键字

当方法的局部变量和类的成员变量重名时，根据“就近原则”，优先使用局部变量

public class This关键字 {
    public static class  Person{
        String name; //自己的名字
        public void sayHello( String name){ //这个参数name和成员变量的name重名
            System.out.println(name+"你好"+",我是"+name);//优先使用局部变量（就近原则）
        }
    }

    public static void main(String[] args) {
        Person person = new Person();
        person.name = "李四";
        /**
         * 将输出“张三你好，我是张三，因为优先使用的name是局部变量name，而不是成员变量的name（就近原则）”
         */
        person.sayHello("张三");


    }
}

如果需要访问本类当中的成员变量，需要使用一个格式：this.成员变量名

public  class  Person{
        String name; //自己的名字

        public void sayHello( String name){ //这个参数name和成员变量的name重名
            System.out.println(name+"你好"+",我是"+this.name);//本来是优先使用局部变量（就近原则）
            System.out.println(this);  //会发现this返回的地址和下面person返回的地址相同，因此可以验证通过谁调用的方法谁就是this                                     
        }


    public static void main(String[] args) {
        Person person = new Person();
        person.name = "李四";
 /**
 * 如果没有this关键字，将输出“张三你好，我是张三“，因为优先使用的name是局部变量name，而不是成员变量的name（就近原则）”
 */
        person.sayHello("张三");

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

        person.name="ZRM";
        person.sayHello("GM");
        System.out.println(person);
     }
}

由此我们可以知道，this可以解决成员变量名和局部变量名的重名问题，那么this到底是怎么解决的呢？原理是什么呢？记住：通过谁调用的方法，谁就是this，即本例中this.name的本质是Person.name

六、构造方法

定义：构造方法是专门用来创建对象的方法，当我们通过new来创建对象时，其实就是在调用构造方法，只不过我们调用的构造方法是由JVM自动提供的一种无参无返回值的构造方法。不信你看，当我们故意错误的写了一个类的时候用new来新建对象，然后把鼠标放在红线上，它会提示：
构造方法的格式：

public 类名称（参数类型  参数名称）{
	方法体
}

注意事项：
（1）构造方法的名称必须和所在的类的名称完全一样，就连大小写也要一样
（2）构造方法不需要写返回值类型，连void也不要写
（3）构造方法不能return一个具体的返回值，但是可以写return ;代表结束（在之前的文章中说过）
（4）如果没有编写任何构造方法,JVM将会默认赠送一个构造方法，没有参数和返回值，方法体什么都不做

public Student(){ }

（5）一旦编写了至少一个构造方法，那么JVM将不再赠送，需要我们自己再写一遍默认的无参构造方法
（6）构造方法也是可以重载的

public Student(){ 
	System.out.println(默认无参构造方法执行啦！);
}
public Student(String name, int age){
	System.out.println(全参构造方法执行啦！！！);
	this.name = name;
	this.age = age;
/**
*当我们要给private修饰的成员变量赋值时，这个时候就不需要Getter/Setter了，可以直接： Student stu2 = new Student("赵丽颖",20);
*/
}

具体示例：

    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;

        }

        public void setName(String str){ //设置姓名
            name = str;
        }

        public String getName(){ //获取姓名
            return name;
        }

        public void setAge(int num){ //设置年龄
            if(num<100&&num>0) {
                age = num;
            }
            else{
                System.out.println("数据不合理！！!");
            }
        }

        public int getAge(){ //获取年龄
            return age;
        }


    public static void main(String[] args) {
        Student stu1 = new Student(); //无参构造
        //这时候就不需要Getter/Setter了
        Student stu2 = new Student("赵丽颖",20);
        System.out.println("姓名："+stu2.getName()+"    年龄；"+stu2.getAge());
        stu2.setAge(21);//但是当我们要去修改成员变量内容的时候，Getter/Setter还是有用的
        System.out.println("姓名："+stu2.getName()+"    年龄；"+stu2.getAge());
    }

}

七、写一个标准的类（非常重要！！！）

一个标准的类通常拥有下面四个组成部分：
1. 所有的成员变量都要使用private关键字修饰
2. 为每一个成员变量编写一对儿Getter/Setter方法
3. 编写一个无参数的构造方法
4. 编写一个全参数的构造方法

在上面的任务中，其实我们只需要自己写第1个：private 成员变量就行了，因为可以使用IDEA自动生成Getter/Setter和两种构造方法。
自动生成步骤：（注意：Student写成Stuent了，最后面完整的代码中已改正）

生成Getter/Setter:

鼠标右击——Generate
点击Getter and Setter
将两项全部选中（按shift键）
点击OK，即可自动生成Getter/Setter的内容

自动生成全参构造方法

右键——Generate和上一步相同
点击Constructor
将两个都选上（按shift键）
点击OK，会自动生成全参构造方法

自动生成无参构造方法

右键——Generate与之前一样
点击Constructor

在这里插入图片描述

点击Select None，即可创建无参构造方法

所以，现在只有private 成员变量是我们自己写的，其他的都可以自动生成出来

最后完成剩下的Student类内容：

package cn.gaomeng.day11;

/**
 * 定义一个标准的学生类
 */
public class Student {
    private  String name; //姓名
    private int 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;
    }


    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {
        Student stu1 = new Student();
/**
*使用无参构造方法
*/
        stu1.setName("灵光二十二");
        stu1.setAge(18);
        System.out.println("姓名："+stu1.getName()+"，年龄："+ stu1.getAge());
        System.out.println("===================================================");
/**
*使用全参构造方法
*/
        Student stu2 = new Student("GM", 18);
        System.out.println("姓名："+stu2.getName()+",年龄："+stu2.getAge());
        stu2.setAge(19); //修改age值
        System.out.println("姓名："+stu2.getName()+",年龄："+stu2.getAge()); //打印修改后的内容


    }

}

运行结果如图：
运行结果图

Madelana

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java开发Day11

类与对象、封装、构造方法一、面向对象思想（一）概述面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事儿区别：（以洗衣服为例）（1)面向过程：强调步骤，这里指的是自己洗衣服的一个挨着一个的步骤（2）面向对象：强调对象，这里的对象就是洗衣机特点：面向对象思想...
复制链接

扫一扫