Java基础Day07

于 2019-10-18 00:58:35 发布
阅读量1.5k 收藏 8
点赞数 7
分类专栏： JAVA基础 JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Riven_x/article/details/102617617
版权

学习目标

1.能够知道类和对象的关系
2.能够完成类的定义及使用
3.能够知道对象在内存中的初始化过程
4.能够知道局部变量和成员变量的区别
5.能够知道private关键字的特点
6.能够知道this关键字的作用
7.能够知道构造方法的格式和注意事项
8.能够完成一个标准类代码的编写及测试

今天的内容可能会有点抽象，但希望大家能够理解面向对象，Java语言是全面象对象的。
想要思维导图笔记的也可以找我下。

1 面向对象思想概述

1.1 面向过程与面向对象（了解）

程序设计思想

面向过程：

​ 分析出解决问题所需要的步骤 ，按每个步骤一步步完成。

​ 代表语言：C语言 嵌入式开发

面向对象：

​ 分析出问题所涉及的所有对象(参与者)，再指挥这些对象解决问题。

​ 代表语言：Java

总结：

​ 面向过程强调步骤和过程，注重如何一步一步解决问题。（强调怎么做）

​ 面向对象强调参与者，即有哪些对象，通过调用不同的对象解决不同的问题。（强调谁来做）

举例：洗衣服

面向过程思想：
	脱衣服-->找个桶-->加水-->放洗衣粉-->浸泡-->搓洗-->漂水-->拧干-->晾晒
	
面向对象思想：
	脱衣服-->打开全自动洗衣机-->放入衣服和洗衣粉-->晾晒
Scanner sc
1.2 面向对象的思想特点

​ 1、更接近现实世界，符合我们的思考习惯。

​ 2、明确功能归属，更容易解决大型的复杂的业务逻辑。

​ 3、从代码角度看，面向对象程序易维护、易复用、易扩展。

​ 4、面向对象的语言有三大特征：封装、继承、多态。

2 类和对象的概述

面向对象语言的基本组成

2.1 什么是类

​ **类：**类是对同一类事物的共同特征（属性、行为）的描述。

​ 比如汽车类，动物类，手机类等。

​ **属性：**就是事物特征的描述信息。（类中对应的是成员变量）

​ 比如人有身高，体重，姓名等属性，手机有颜色，价格，品牌等属性。

​ **行为：**就是事物能够做什么，有什么功能。（类中对应的是成员方法）

​ 比如人有走路，说话，吃饭等行为，手机有拍照，打电话等功能。

2.2 什么是对象

​ 对象是事物的具体体现，是类真实存在的一个实例。

​ 举例：学生张三是学生类的一个对象。

2.3 类和对象的关系

​ 1)、类是对事物的描述，是一个抽象的概念。

​ 2)、对象是事物的具体实例，是真实存在的。

​ 3)、java开发中，需要先有类，才能创建该类的对象。一个类能创建出多个对象。

简单理解：类是对象的模板，对象是类的实例，通过类创建对象。
在这里插入图片描述

3 类的定义和使用

3.1 类的定义格式
public  class  类名{

}
3.2 成员变量

​ 用于描述类的属性。

​ 与变量的定义格式一样，只是定义位置发生了改变：定义在类中方法外。

​ 成员变量可以不手动初始化就使用，因为有默认初始化值。

3.3 成员方法

​ 用于描述类的行为或功能。

​ 与之前学的方法的定义一样，只是少了static关键字。

示例代码：

/*
    手机类 Phone：
        成员变量：
        品牌(brand)
        价格(price)

        成员方法：
        打电话(call)
        发短信(sendMessage)
 */
public class Phone {
    //成员变量
    String brand; //品牌
    int price; //价格

    //成员方法（打电话）
    public void call() {
        System.out.println("打电话");
    }
	
    //成员方法（发短信）
    public void sendMessage() {
        System.out.println("发短信");
    }
}
3.4 对象的使用
创建对象的格式：
	类名 对象名 = new 类名();

调用成员的格式：
	对象名.成员变量
	对象名.成员方法();

/*
	类的使用示例代码
*/
public class PhoneDemo {
    public static void main(String[] args) {
        //创建对象
        Phone p = new Phone();

        //访问成员变量，成员变量保存在堆内存中，所以有默认值
        System.out.println(p.brand);
        System.out.println(p.price);
		
        //为成员变量赋值
        p.brand = "小米";
        p.price = 2999;

        System.out.println(p.brand);
        System.out.println(p.price);

        //调用成员方法
        p.call();
        p.sendMessage();
    }
}
3.5 学生类案例

需求：

1、定义一个学生类Student，包含：

​ 成员变量：姓名，年龄

​ 成员方法：学习，做作业

2、定义学生测试类，在测试类中创建学生类的对象，调用成员变量和成员方法。

案例代码：

/*
	创建学生类
*/
public class Student {
    //成员变量
    String name;  //姓名
    int age;   //年龄

    //成员方法
    public void study() {
        System.out.println("好好学习，天天向上");
    }
    
    public void doHomework() {
        System.out.println("键盘敲烂，月薪过万");
    }
}

/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        //使用对象访问成员变量
        System.out.println(s.name + "," + s.age);
        s.name = "林志玲";
        s.age = 30;

        System.out.println(s.name + "," + s.age);
		//使用对象调用成员方法
        s.study();
        s.doHomework();
    }
}

练习代码：


  需求：
 	1. 定义电脑类Computer，类中包含以下内容：
        成员变量：
            品牌（brand）
            价格（price）
        成员方法：
            写代码 (coding)
    2. 定义测试类ComputerDemo, 创建类的对象，为成员变量赋值，并调用成员方法

4 对象内存图

4.1 单个对象内存图

在这里插入图片描述

对象创建过程:
	1. 首次创建对象时, 类加载器会先加载类的字节码文件(class文件)，该过程只会执行一次.
    2. 根据类的模板信息, 分配内存并创建对象, 给出成员变量默认值, 并返回对象内存地址.
    3. 在栈内存中, 通过对象名保存对象地址值, 以此可以访问对象的成员信息.
4.2 多个对象内存图

创建多个对象，系统会为多个对象独立分配内存，并为各自对象的成员变量赋默认值。

4.2 多个对象指向相同内存图

​ 多个对象指向相同内存图，就是说多个对象存储了相同的内存地址值，任意一个对象改变了堆内存中的成员变量值，其他的所有对象都会受到影响，访问到就是修改后的值。
在这里插入图片描述

5 成员变量和局部变量

成员变量

​ 定义在类中，方法外，属于类的成员，使用对象名访问。

局部变量

​ 定义在方法内或者形参列表上的变量。

public class Test{
    // 成员变量: 定义在类中，方法外.
    String name;
    int age;
    
    // 局部变量: 定义在方法内 或者 形参列表上.（a , b , c 都是局部变量）
    public void sum(int a, int b){
        int c = a + b;
        System.out.println(c);
        System.out.println(age);//访问成员变量
    }

}

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

定义位置内存位置生命周期初始化值作用范围
成员变量在类中，方法外堆内存随对象的创建而创建，随对象的消失而消失。有默认值能被类中的所有方法访问。
局部变量方法中或参数列表中栈内存随方法的调用而创建，方法的结束而消失。没有默认值，必须先赋值后使用只能在变量所在的方法内使用。

6 private和this关键字

6.1 private关键字

private的特点：

​ 1、private是权限修饰符，代表私有的意思。

​ 2、可以修饰成员变量和成员方法。

​ 3、被private修饰的成员只能在本类中使用。

public class Student {
	private int age; /
        
         我/该变量只能在本类中使用
}

为了在其他类中能使用被private修饰的成员变量，一般会提供一对公有（public修饰）的getter和setter方法，用于获取和设置成员变量的值。

/*
    学生类
 */
public class Student {
    //成员变量
    String name;
    //私有成员变量
    private int age;

    //setter方法，用于设置成员变量的值
    public void setAge(int a) {
        //可以在方法内进行数据合法性检验
        if(a<0 || a>120) {
            System.out.println("你给的年龄有误");
        } else {
            age = a;
        }
    }
	
    //getter方法，用于获取成员变量的值
    public int getAge() {
        return age;
    }

    //成员方法
    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        //给成员变量赋值
        s.name = "林志玲";
        s.setAge(35);
        //调用方法
        s.show();
    }
}
6.2 private的使用

标准类的定义步骤：

​ 1、使用private修饰成员变量。

​ 2、提供public修饰的getter和setter方法。

getter和setter方法的命名规范：

​ getter方法用于获取成员变量的值，所以方法有返回值，方法名为：get+成员变量名首字母大写。

​ setter方法用于设置成员变量的值，所以方法有参数，方法名为：set+成员变量名首字母大写。

案例代码：

/*
需求：
    1. 定义标准的学生类，要求name和age使用private修饰，并提供set和get方法，以及显示数据的show方法。
    2. 测试类中创建对象并使用，最终在控制台输出name和age的值。    
 */
public class Student {
    // 1. 私有成员变量
    private String name;
    private int age;

    // 2. 公有getter 和 setter方法
    public void setName(String n) {
        name = n;
    }
    public String getName() {
        return name;
    }
    
    public void setAge(int a) {
        age = a;
    }
    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();

        //使用set方法给成员变量赋值
        s.setName("林志玲");
        s.setAge(35);

        s.show();

        //使用get方法获取成员变量的值
        System.out.println(s.getName() + "," + s.getAge());
    }
}
6.3 this关键字

1、变量的访问规则？

​ 当方法内的局部变量和类的成员变量同名时，变量的访问遵循就近原则。

2、this关键字的作用（使用场景）？

​ 当方法内局部变量和类的成员变量同名时，使用this关键字访问类的成员变量。

​ 格式：this.成员变量名

3、this关键字的内存原理？

​ this代表当前对象的引用，哪个对象在调用方法，this就代表那个对象。

/*
    this：代表当前对象的引用，哪个对象调方法，this就代表谁。
*/
public class Student {
	
    //在学生类中定义方法，输出this的值
    public void printThis(){
        System.out.println("this值："+this); 
    }


}

public class ThisDemo{
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println("对象s的值："+s); //Student@3fb6a447
        
        s.printThis(); //当前s对象在调用方法printThis，所以在方法内打印的this的值和s对象的地址一样
        			   //Student@3fb6a447
    }
}

使用this改造学生类

public class Student {
    // 1. 私有成员变量
    private String name;
    private int age;

    // 2. 公有getter 和 setter方法
    public void setName(String name) {
        //参数名和成员变量相同，使用this访问成员变量name
        this.name = name;
    }

    public String getName() {
        //因为此处成员变量name没有重名，可以不用this来访问
        //return this.name;
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

快速生成getter和setter方法

快捷键：Alt + Insert

在这里插入图片描述

7 封装

封装的体现:

​ 1 私有成员变量, 公有get和set方法。

​ 2 方法的定义和使用 。

​ 3 类的定义和使用 。

7.1 封装的概述
  • 封装是一种程序设计思想
  • 封装是面向对象的三大特征之一。面向对象的三大特性是：封装、继承、多态。
7.2 封装的原则
  • 原则：对类中的成员进行合理隐藏，合理暴露。
  • 合理隐藏：使用private私有类的成员变量或核心方法，不允许外部直接访问。
  • 合理暴露：对私有的成员变量提供public修饰的get/set方法，既能保证数据安全，又能实现数据访问。
7.3 封装的好处
  • 通过方法来控制成员变量的操作，提高了数据的安全性。
  • 把代码用方法进行封装，提高了代码的复用性。

8 构造方法

8.1 构造方法概述和作用

​ 构造方法是一种特殊的方法，构造方法也叫构造函数或者构造器。

​ 构造方法用于创建对象，并完成成员变量的初始化。

8.2 构造方法的格式
修饰符  类名(参数列表){
    //初始化代码
}
修饰符：一般都是public

构造方法特点：

​ 1)、构造方法没有返回值，连void也不能写，构造方法名和类名相同。

​ 2)、构造方法在创建对象时，通过new关键字调用，每创建一个对象，就会执行一次构造方法。

//学生类
public class Student {
    private String name;
    private int age;

    //无参构造方法
    public Student() {
        System.out.println("无参构造方法");
    }
    
    //有参构造方法（可以通过参数传值完成成员变量的初始化）
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("有参构造方法");
    }

}

//测试类
public class StudentDemo {
    public static void main(String[] args) {
        //调用无参构造方法创建对象,成员变量由系统给出默认值。
        Student s = new Student();
        System.out.println(s.getName());  //初始值 null
        System.out.println(s.getAge()); //初始值 0
        
         //调用有参构造方法创建对象，并完成对象的初始化。
        Student s = new Student("张三", 18);
        System.out.println(s.getName());  //输出：张三
        System.out.println(s.getAge()); // 输出：18
    }
}
8.3 构造方法的注意事项

（1）、如果类中没有定义构造方法，系统会提供一个默认的无参构造方法。

（2）、如果类中定义了有参构造方法，那么系统将不再提供默认的无参构造方法。

​ 这时如果还想使用无参构造方法创建对象，就必须手动添加无参构造方法。

​ 建议：定义类时都手动给出无参构造方法。

（3）、构造方法是可以重载的。

/*
 * 定义学生类，提供无参和有参构造方法。
 */
public class Student {
	
	private String name;
	private int age;
    
  	//此处省略getter和setter方法
	
	//无参构造方法
	public Student(){}
	
	//有参构造方法，用于为成员变量name赋值
	public Student(String name){
		this.name = name;
	}
    
	//有参构造方法，用于为成员变量age赋值
	public Student(int age){
		this.age = age;
	}
	
	//满参构造方法：为所有成员变量赋值
	public Student(String name,int age){
		this.name = name;
		this.age = age;
	}
    
    //成员方法: 用于显示数据
     public void show() {
        System.out.println(name + ":" + age);
    }
}


//测试类
public class StudentDemo {
    public static void main(String[] args) {
        //调用无参构造方法创建对象
        Student s1 = new Student();
        s1.show();

        //调用有参构造方法，初始化name成员变量
        Student s2 = new Student("隔壁老王");
        s2.show();

        //调用有参构造方法，初始化age成员变量
        Student s3 = new Student(30);
        s3.show();

        //调用满参构造方法
        Student s4 = new Student("隔壁老王",30);
        s4.show();
    }
}

快速生成构造方法

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

9 标准类的制作

步骤：

  1. 使用private私有成员变量。
  2. 提供公有的getter和setter方法用于操作成员变量。
  3. 提供无参和有参构造方法。
  4. 根据类的其他需要需要添加成员方法。
/*
 * 	需求：定义一个标准学生类
 */
public class Student {
	
	//1、使用private私有成员变量。
	private String name;
	private int age;
	
	//2、提供公有的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;
	}
	
	//3、提供无参和有参构造方法。
	//无参构造方法
	public Student(){
		
	}
	//有参构造方法
	public Student(String name,int age){
		this.name = name;
		this.age = age;
	}
    
    //4、根据类的其他需要需要添加成员方法。
    public void show() {
        System.out.println(name + "," + age);
    }
}

//测试类
public class StudentDemo {
    public static void main(String[] args) {
        
        //方式1：使用setter方法完成成员变量的赋值
        Student s1 = new Student();
        s1.setName("林志玲");
        s1.setAge(30);
        s1.show();

        //方式2：使用满参构造方法完成成员变量的赋值
        Student s2 = new Student("林志玲",30);
        //s2 = new Student("林志玲",31);
        s2.setAge(31);
        s2.show();
        
    }
}

给成员变量赋值的方式：

​ 1、通过setXxx()方法。

​ 2、通过有参构造方法。

使用区别：

​ 构造方法一般用于创建对象并完成成员变量初始化赋值，setter方法一般用于对象创建之后，改变对象的成员变量的值。

Riven_x
关注
  • 7
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值