类对象封装构造方法

类与对象练习
关注我即可免费下载

文章目录

面向对象思想概述

Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下，
使用Java语言去设计、开发计算机程序。这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面
向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算
机事件的设计思想。

面向过程与面向对象的区别:
面向过程：强调步骤。
面向对象：强调对象。

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

类和对象

类与对象的关系

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

类的定义

类的定义格式

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

定义类 ：就是定义类的成员，包括成员变量和成员方法。
成员变量 ：和以前定义变量几乎是一样的。只不过位置发生了改变。在类中，方法外。
成员方法 ：和以前定义方法几乎是一样的。只不过把static去掉，static的作用在面向对象后面课程中再详细讲解。

类的定义格式举例：

public class Student {
    
    
//成员变量
String name；//姓名
int age；//年龄
//成员方法
//学习的方法
public void study() {
    
    
System.out.println("好好学习，天天向上");
}
//吃饭的方法
public void eat() {
    
    
System.out.println("学习饿了要吃饭");
}
}

对象的使用

对象的使用格式
创建对象：

类名 对象名 = new 类名();

使用对象访问类中的成员:

对象名.成员变量；
对象名.成员方法()；

对象的使用格式举例：

public class Test01_Student {
    
    
public static void main(String[] args) {
    
    
//创建对象格式：类名 对象名 = new 类名();
Student s = new Student();
System.out.println("s:"+s); //com.kkb.Student@100363
//直接输出成员变量值
System.out.println("姓名："+s.name); //null
System.out.println("年龄："+s.age); //0
System.out.println("----------");
//给成员变量赋值
s.name = "赵丽颖";
s.age = 18;
//再次输出成员变量的值
System.out.println("姓名："+s.name); //赵丽颖
System.out.println("年龄："+s.age); //18
System.out.println("----------");
//调用成员方法
s.study(); // "好好学习，天天向上"
s.eat(); // "学习饿了要吃饭"
}
}

成员变量的默认值

数据类型	默认值
整数（byte，short，int，long）	0
浮点数（float，double）	0.0
字符（char）	‘\u0000’
布尔（boolean）	false
数组，类，接口	null

在这里插入图片描述

局部变量和成员变量的区别
1.在类中的位置不同【重点】
成员变量：类中，方法外
局部变量：方法中或者方法声明上(形式参数)
2.在内存中的位置不同（了解）
成员变量：堆内存
局部变量：栈内存
3.生命周期不同（了解）
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
4.初始化值的不同【重点】
成员变量：有默认值
局部变量：没有默认值。必须先定义，赋值，最后使用
5.作用范围不一样【重点】
成员变量：类中
局部变量：方法中

封装概述

面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。
封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的
方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。

封装的步骤

使用 private 关键字来修饰成员变量。
对需要访问的成员变量，提供对应的一对 getXxx 方法、 setXxx 方法。

封装的操作——private关键字

private的含义

private是一个权限修饰符，代表最小权限。
可以修饰成员变量和成员方法。
被private修饰后的成员变量和成员方法，只在本类中才能访问。

private的使用格式

private 数据类型 变量名 ；

使用 private 修饰成员变量，代码如下：

public class Student {
    
    
private String name;
private int age;
}

提供 getXxx 方法 / setXxx 方法，可以访问成员变量，代码如下：

public class Student {
    
    
private String name;
private int age;
public void setName(String n) {
    
    
name = n;
}
public String getName() {
    
    
return name;
}
public void setAge(int a) {
    
    
age = a;
}
public int getAge() {
    
    
return age;
}
}

封装优化1——this关键字

我们发现 setXxx 方法中的形参名字并不符合见名知意的规定，那么如果修改与成员变量名一致，是否就见名知意
了呢？代码如下：

public class Student {
    
    
private String name;
private int age;
public void setName(String name) {
    
    
name = name;
}
public void setAge(int age) {
    
    
age = age;
}
}

经过修改和测试，我们发现新的问题，成员变量赋值失败了。也就是说，在修改了 setXxx() 的形参变量名后，方
法并没有给成员变量赋值！这是由于形参变量名与成员变量名重名，导致成员变量名被隐藏，方法中的变量名，无
法访问到成员变量，从而赋值失败。所以，我们只能使用this关键字，来解决这个重名问题。

this的含义
this代表所在类的当前对象的引用（地址值），即对象自己的引用。
方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁。
this使用格式

this.成员变量名；

使用 this 修饰方法中的变量，解决成员变量被隐藏的问题，代码如下：

public class Student {
    
    
private String name;
private int age;
public void setName(String name) {
    
    
//name = name;
this.name = name;
}
public String getName() {
    
    
return name;
}
public void setAge(int age) {
    
    
//age = age;
this.age = age;
}
public int getAge() {
    
    
return age;
}
}

方法中只有一个变量名时，默认也是使用 this 修饰，可以省略不写。

封装优化2——构造方法

当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。无论你与否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个无参数构造方法，一旦自己定义了构造方法，Java自动提供的默认无参数构造方法就会失效。
构造方法的定义格式

修饰符 构造方法名(参数列表){
    
    
// 方法体
}

构造方法的写法上，方法名与它所在的类名相同。它没有返回值，所以不需要返回值类型，甚至不需要void。使用
构造方法后，代码如下：

public class Student {
    
    
private String name;
private int age;
// 无参数构造方法
public Student() {
    
    }
// 有参数构造方法
public Student(String name,int age) {
    
    
this.name = name;
this.age = age;
}
}

注意事项

如果你不提供构造方法，系统会给出无参数构造方法。
如果你提供了构造方法，系统将不再提供无参数构造方法。
构造方法是可以重载的，既可以定义参数，也可以不定义参数。

标准代码——JavaBean

JavaBean 是 Java语言编写类的一种标准规范。符合 JavaBean 的类，要求类必须是具体的和公共的，并且具有无参数的构造方法，提供用来操作成员变量的 set 和 get 方法。

public class ClassName{
    
    
//成员变量
//构造方法
//无参构造方法【必须】
//有参构造方法【建议】
//成员方法
//getXxx()
//setXxx()
}

编写符合 JavaBean 规范的类，以学生类为例，标准代码如下：

public class Student {
    
    
//成员变量
private String name;
private int age;
//构造方法
public Student() {
    
    }
public Student(String name,int age) {
    
    
this.name = name;
this.age = age;
}
//成员方法
publicvoid setName(String name) {
    
    
this.name = name;
}
public String getName() {
    
    
return name;
}
publicvoid setAge(int age) {
    
    
this.age = age;
}
publicint getAge() {
    
    
return age;
}
}

测试类，代码如下：

public class TestStudent {
    
    
public static void main(String[] args) {
    
    
//无参构造使用
Student s= new Student();
s.setName("柳岩");
s.setAge(18);
System.out.println(s.getName()+"---"+s.getAge());
//带参构造使用
Student s2= new Student("赵丽颖",18);
System.out.println(s2.getName()+"---"+s2.getAge());
}
}

Java API

Random 类
Random 类似Scanner，也是Java提供好的API，内部提供了产生随机数的功能
使用步骤：

导入包

import java.util.Random ;

创建对象

Random r = new Random();

产生随机数

int num = r.nextInt(10) ;

解释： 10代表的是一个范围，如果括号写10，产生的随机数就是0(包括)-9(包括)，括号写20，参数的随
机数则是0(包括)-19(包括)

使用 Random类，完成生成3个10以内的随机整数的操作，代码如下：

//1. 导包
import java.util.Random;
public class Demo01_Random {
    
    
public static void main(String[] args) {
    
    
//2. 创建键盘录入数据的对象
Random r = new Random();
for(int i = 0; i < 3; i++){
    
    
//3. 随机生成一个数据
int number = r.nextInt(10);
//4. 输出数据
System.out.println("number:"+ number);
}
}
}

Scanner 类

Scanner类的使用步骤
数据输入是指获取用户键盘录入的数据，那么在java语言中，怎样实现呢？
我们可以通过 Scanner 类来获取用户的输入。
导包
使用import关键字导包，在类的所有代码之前导包，引入要使用的类型，java.lang包下的所有类无需导入。
Scanner 类在java.util包下，所以需要将该类导入。

格式：import 包名.类名;
举例：import java.util.Scanner;
创建对象
格式：数据类型变量名 = new 数据类型(参数列表);
eg:Scanner sc = new Scanner(System.in);
调用方法
格式：变量名.方法名();
举例：int i = sc.nextInt(); // 接收一个键盘录入的整数
示例
获取键盘录入的整数

import java.util.Scanner;
public class ScannerDemo {
    
    
public static void main(String[] args) {
    
    
//创建对象
Scanner sc = new Scanner(System.in);
//接收数据
int x = sc.nextInt();
//输出数据
System.out.println("x:" + x);
}
}

BigInteger 类

概述
java.math.BigInteger 类，不可变的任意精度的整数。如果运算中，数据的范围超过了long类型后，可以使用BigInteger类实现，该类的计算整数是不限制长度的。
构造方法
BigInteger(String value) 将 BigInteger 的十进制字符串表示形式转换为 BigInteger。超过long类型的范围，已经
不能称为数字了，因此构造方法中采用字符串的形式来表示超大整数，将超大整数封装成BigInteger对象。

方法名	含义
add(BigInteger value)	返回其值为 (this + val) 的 BigInteger，超大整数加法运算
subtract(BigInteger value)	返回其值为 (this - val) 的 BigInteger，超大整数减法运算
multiply(BigInteger value)	返回其值为 (this * val) 的 BigInteger，超大整数乘法运算
divide(BigInteger value)	返回其值为 (this / val) 的 BigInteger，超大整数除法运算，除不尽取整数部分

public static void main(String[] args){
    
    
BigInteger big1 = new BigInteger("987654321123456789000");
BigInteger big2 = new BigInteger("123456789987654321");
//加法运算
BigInteger add = big1.add(big2);
System.out.println("求和:"+add);
//减法运算
BigInteger sub = big1.subtract(big2);
System.out.println("求差:"+sub);
//乘法运算
BigInteger mul = big1.multiply(big2);
System.out.println("乘积:"+mul);
//除法运算
BigInteger div = big1.divide(big2);
System.out.println("除法:"+div);
}

BigDecimal 类

概述
java.math.BigDecimal 类，不可变的、任意精度的有符号十进制数。该类可以实现超大浮点数据的精确运算。
构造方法
BigDecimal(String value)将 BigDecimal的十进制字符串表示形式转换为 BigDecimal。
常用方法
BigDecimal类的加法减法乘法与BigInteger类相同，不在重复。
除法计算
BigDecimal类实现精确的浮点数除法运算，如果两个浮点除法计算后是无限循环，那么就会抛出异常。
除法运算方法：

BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)
-divesor ：此 BigDecimal 要除以的值。
-scale ：保留的位数
-roundingMode ：舍入方式
舍入方式： BigDecimal类提供静态的成员变量来表示舍入的方式
-BigDecimal.ROUND_UP 向上加1。
-BigDecimal.ROUND_DOWN 直接舍去。
-BigDecimal.ROUND_HALF_UP 四舍五入。

public static void main(String[] args){
    
    
BigDecimal big1 = new BigDecimal("5.25");
BigDecimal big2 = new BigDecimal("3.25");
//加法计算
BigDecimal add = big1.add(big2);
System.out.println("求和:"+add);
//减法计算
BigDecimal sub = big1.subtract(big2);
System.out.println("求差:"+sub);
//乘法计算
BigDecimal mul = big1.multiply(big2);
System.out.println("乘法:"+mul);
//除法计算
BigDecimal div = big1.divide(big2,2,BigDecimal.ROUND_HALF_UP);
System.out.println(div);
}