面向对象基础–中

今日内容

封装
权限修饰符
构造器
this
包
static修饰符
数组工具类

教学目标

理解封装的概念
掌握属性的封装
掌握权限修饰符的使用
掌握构造器的声明与使用
掌握this关键字的使用
掌握包的定义和导入

第六章面向对象基础–中

6.1 封装

6.1.1 封装概述

1、为什么需要封装？

我要用洗衣机，只需要按一下开关和洗涤模式就可以了。有必要了解洗衣机内部的结构吗？有必要碰电动机吗？
我要开车，…

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

3、这个就是我们说的“高内聚，低耦合”的体现之一：

高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：仅对外暴露少量的方法用于使用

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的讲，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

4、封装的设计思想的应用

（1）类的封装：把属性和方法封装到类的内部，外部通过调用方法完成指定的功能，不需要了解类的内部实现

（2）组件的封装：例如支付宝等支付组件，对外只提供使用接口，我们不需要也无法了解内部的实现

（3）系统的封装：例如我们使用操作系统等，我们只需要知道怎么用，不需要了解内部的实现

6.1.2 属性的封装

原则

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

属性封装的目的

隐藏类的实现细节
让使用者只能通过事先预定的方法来访问数据，从而可以在该方法里面加入控制逻辑，限制对成员变量的不合理访问。
可以进行数据检查，从而有利于保证对象信息的完整性。
便于修改，提高代码的可维护性。

实现步骤

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

6.1.3 权限修饰符

在这里插入图片描述

扫描二维码关注公众号，回复： 16756023 查看本文章

对于类的成员：四种权限修饰符都可以使用

对于外部的类：只能使用public和缺省两种

在这里插入图片描述

练习1

（1）定义学生类Student

声明姓名和成绩实例变量，私有化，提供get/set

getInfo()方法：用于返回学生对象的信息

（2）测试类ObjectArrayTest的main中创建一个可以装3个学生对象的数组，并且按照学生成绩排序，显示学生信息

class Test22_Exer{
    
    
	public static void main(String[] args){
    
    
		//创建一个可以装3个学生对象的数组
		Student[] arr = new Student[3];//只是申明这个数组，可以用来装3个学生，此时里面没有学生对象
		
		//手工赋值
		arr[0] = new Student();
		arr[0].setName("张三");
		arr[0].setScore(78);
		
		arr[1] = new Student();
		arr[1].setName("李四");
		arr[1].setScore(96);
		
		arr[2] = new Student();
		arr[2].setName("王五");
		arr[2].setScore(56);
		
		//先显示一下目前的顺序
		for(int i=0; i<arr.length; i++){
    
    
			System.out.println(arr[i].getInfo());
		}
		
		System.out.println("------------------------------------------");
		//冒泡排序
		for(int i=1; i<arr.length; i++){
    
    
			for(int j=0; j<arr.length-i; j++){
    
    
				//arr[j] > arr[j+1]//错误的
				if(arr[j].getScore() > arr[j+1].getScore()){
    
    
					//交换两个元素，这里是两个学生对象，所以temp也得是Student类型
					Student temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		//再显示一下目前的顺序
		for(int i=0; i<arr.length; i++){
    
    
			System.out.println(arr[i].getInfo());
		}
	}
}
class Student{
    
    
	private String name;
	private int score;//使用int或double都可以
	
	//get/set方法，
	public void setName(String n){
    
    
		name = n;
	}
	public String getName(){
    
    
		return name;
	}
	public void setScore(int s){
    
    
		score = s;
	}
	public int getScore(){
    
    
		return score;
	}
	
	public String getInfo(){
    
    
		return "姓名：" + name +"，成绩：" + score;
	}
}

class Test22_Exer_2{
    
    
	public static void main(String[] args){
    
    
		//创建一个可以装3个学生对象的数组
		Student[] arr = new Student[3];//只是申明这个数组，可以用来装3个学生，此时里面没有学生对象
		
		//从键盘输入
		java.util.Scanner input = new java.util.Scanner(System.in);
		for(int i=0;i<arr.length; i++){
    
    
			System.out.println("请输入第" + (i+1) + "个学生信息：");
			arr[i] = new Student();
			
			System.out.print("姓名：");
			String name = input.next();
			arr[i].setName(name);
			
			System.out.print("成绩：");
			arr[i].setScore(input.nextInt());
		}
		
		//先显示一下目前的顺序
		for(int i=0; i<arr.length; i++){
    
    
			System.out.println(arr[i].getInfo());
		}
		
		System.out.println("------------------------------------------");
		//冒泡排序
		for(int i=1; i<arr.length; i++){
    
    
			for(int j=0; j<arr.length-i; j++){
    
    
				//arr[j] > arr[j+1]//错误的
				if(arr[j].getScore() > arr[j+1].getScore()){
    
    
					//交换两个元素，这里是两个学生对象，所以temp也得是Student类型
					Student temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		//再显示一下目前的顺序
		for(int i=0; i<arr.length; i++){
    
    
			System.out.println(arr[i].getInfo());
		}
	}
}
class Student{
    
    
	private String name;
	private int score;//使用int或double都可以
	
	//get/set方法，
	public void setName(String n){
    
    
		name = n;
	}
	public String getName(){
    
    
		return name;
	}
	public void setScore(int s){
    
    
		score = s;
	}
	public int getScore(){
    
    
		return score;
	}
	
	public String getInfo(){
    
    
		return "姓名：" + name +"，成绩：" + score;
	}
}

6.2 构造器（Constructor)

构造器又称为构造方法，那是因为它长的很像方法。但是和方法还有有所区别的。

构造器的作用

要创建一个类的实例对象，必须调用一个对象的构造器，来完成类的实例初始化过程。实例初始化过程就是为实例变量赋初始值的过程。

当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。

小贴士：无论你与否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个无参数构造方法，一旦自己定义了构造方法，Java自动提供的默认无参数构造方法就会失效。

构造方法的定义格式

【修饰符】 构造器名(){
    
    
    // 实例初始化代码
}
【修饰符】 构造器名(参数列表){
    
    
	// 实例初始化代码
}

代码如下：

public class Student {
    
    
	private String name;
	private int age;
	// 无参构造
  	public Student() {
    
    } 
 	// 有参构造
  	public Student(String n,int a) {
    
    
		name = n;
    	age = a; 
	}
    //此处其他代码省略
}

注意事项

构造器名必须与它所在的类名必须相同。
它没有返回值，所以不需要返回值类型，甚至不需要void
如果你不提供构造器，系统会给出无参数构造器，并且该构造器的修饰符默认与类的修饰符相同
如果你提供了构造器，系统将不再提供无参数构造器，除非你自己定义。
构造器是可以重载的，既可以定义参数，也可以不定义参数。
构造器不能被static、final、synchronized、abstract、native修饰

练习

（1）声明一个员工类，

包含属性：编号、姓名、薪资、性别，要求属性私有化，提供get/set，
提供无参构造器和有参构造器
提供getInfo()

（2）在测试类的main中分别用无参构造和有参构造创建员工类对象，调用getInfo

class Test02_Constructor_Exer{
    
    
	public static void main(String[] args){
    
    
		//分别用无参构造和有参构造创建对象，调用getInfo
		Employee e1 = new Employee();
		System.out.println(e1.getInfo());
		
		Employee e2 = new Employee("1001","张三",110000,'男');
		System.out.println(e2.getInfo());
		
		e2.setSalary(120000);
		System.out.println(e2.getInfo());
		
		System.out.println("e1薪资：" + e1.getSalary());
	}
}
class Employee{
    
    
	private String id;
	private String name;
	private double salary;
	private char gender;
	
	//提供无参构造器和有参构造器
	Employee(){
    
    
		
	}
	Employee(String i, String n){
    
    
		id = i;
		name = n;
	}
	Employee(String i, String n, double s, char g){
    
    
		id = i;
		name = n;
		salary = s;
		gender = g;
	}
	
	//提供get/set，
	public void setId(String i){
    
    
		id = i;
	}
	public String getId(){
    
    
		return id;
	}
	public void setName(String n){
    
    
		name = n;
	}
	public String getName(){
    
    
		return name;
	}
	public void setSalary(double s){
    
    
		salary = s;
	}
	public double getSalary(){
    
    
		return salary;
	}
	public void setGender(char g){
    
    
		gender = g;
	}
	public char getGender(){
    
    
		return gender;
	}
	//提供getInfo()
	public String getInfo(){
    
    
		return "编号：" + id + "，姓名：" + name + "，薪资：" + salary + "，性别：" +gender;
	}
}

6.3 this关键字

我们发现 setXxx 方法中的形参名字和构造器的形参名称并不符合见名知意的规定，那么如果修改与成员变量名一致，会怎么样呢？代码如下：

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

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

	public void setName(String name) {
    
    
		name = name;
	}

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

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

this的含义

this代表当前对象的引用（地址值），即对象自己的引用。

this可以用于构造器中：表示正在创建的那个实例对象，即正在new谁，this就代表谁
this用于实例方法中：表示调用该方法的对象，即谁在调用，this就代表谁。

this使用格式

1、this.成员变量名

当方法的局部变量与当前对象的成员变量重名时，就可以在成员变量前面加this.，如果没有重名问题，就可以省略this.

this.成员变量名；

2、this.成员方法

调用当前对象自己的成员方法时，都可以加"this."，也可以省略，实际开发中都省略

【变量=】this.成员方法(【实参列表】);

3、this()或this(实参列表)

当需要调用本类的其他构造器时，就可以使用该形式。

要求：

必须在构造器的首行

如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了"this(【实参列表】)"，否则会发生递归调用死循环

练习

（1）声明一个员工类，

包含属性：编号、姓名、薪资、性别，要求属性私有化，提供get/set，
提供无参构造器和有参构造器
提供getInfo()

（2）在测试类的main中分别用无参构造和有参构造创建员工类对象，调用getInfo

6.4 标准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;
	}

	// get/set成员方法
	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 String getInfo(){
    
    
        return "姓名：" + name + "，年龄：" + 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());
        System.out.println(s.getInfo());

		// 带参构造使用
		Student s2 = new Student("赵丽颖", 18);
		System.out.println(s2.getName() + "---" + s2.getAge());
        System.out.println(s2.getInfo());
	}
}

6.5 包（Package）

6.5.1 包的作用

1、可以避免类重名

有了包之后，类的全名称就变为：包.类名

2、分类组织管理众多的类

例如：

java.lang----包含一些Java语言的核心类，如String、Math、Integer、 System和Thread等，提供常用功能
java.net----包含执行与网络相关的操作的类和接口。
java.io ----包含能提供多种输入/输出功能的类。
java.util----包含一些实用工具类，如集合框架类、日期时间、数组工具类Arrays，文本扫描仪Scanner，随机值产生工具Random。
java.text----包含了一些java格式化相关的类
java.sql和javax.sql----包含了java进行JDBC数据库编程的相关类/接口
java.awt和java.swing----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。

3、可以控制某些类型或成员的可见范围

如果某个类型或者成员的权限修饰缺省的话，那么就仅限于本包使用

6.5.2 声明包的语法格式

package 包名;

注意：

(1)必须在源文件的代码首行

(2)一个源文件只能有一个声明包的语句

包的命名规范和习惯：
（1）所有单词都小写，每一个单词之间使用.分割
（2）习惯用公司的域名倒置

例如：com.atguigu.xxx;

建议大家取包名时不要使用“java.xx"包

6.5.3 如何编译和运行（了解，之后在idea中就不用了）

编译格式：

javac -d class文件存放路径 源文件路径名.java

例如：

package com.atguigu.demo;

public class TestPackage {
    
    
	public static void main(String[] args) {
    
    
		System.out.println("hello package");
	}
}

编译：

javac -d . TestPackage.java

其中 . 表示在当前目录生成包目录

运行：

java com.atguigu.demo.TestPackage

定位到com目录的外面才能正确找到这个类

使用类的全名称才能正确运行这个类

6.5.4 使用其他包的类

前提：被使用的类或成员的权限修饰符是>缺省的

（1）使用类型的全名称

例如：java.util.Scanner input = new java.util.Scanner(System.in);

（2）使用import 语句之后，代码中使用简名称

import语句告诉编译器到哪里去寻找类。

import语句的语法格式：

import 包.类名;
import 包.*;
import static 包.类名.静态成员; //后面补充

注意：

使用java.lang包下的类，不需要import语句，就直接可以使用简名称

import语句必须在package下面，class的上面

当使用两个不同包的同名类时，例如：java.util.Date和java.sql.Date。一个使用全名称，一个使用简名称

示例代码：

package com.atguigu.bean;

public class Student {
    
    
	// 成员变量
	private String name;
	private int age;

	// 构造方法
	public Student() {
    
    
	}

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

	// 成员方法
	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;
	}
}

package com.atguigu.test;

import java.util.Scanner;
import java.util.Date;
import com.atguigu.bean.Student;

public class Test{
    
    
    public static void main(String[] args){
    
    
        Scanner input = new Scanner(System.in);
        Student stu = new Student();
        String str = "hello";
        
        Date now = new Date();
        java.sql.Date d = new java.sql.Date(346724566);        
    }
}

6.6 static

static是一个成员修饰符，可以修饰类的成员：成员变量、成员方法、成员内部类（后面讲）、代码块（后面讲）。被修饰的成员是属于类的，而不是单单是属于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。

6.6.1 静态方法

static修饰的成员方法，称为类方法、静态方法。

语法格式：

【其他修饰符】 static 返回值类型 方法名 (【形参列表】){
    
     
	// 执行语句 
}

（1）在本类中，静态方法可以直接访问静态方法和静态变量。

（2）在其他类中：可以使用“类名.方法"进行调用，也可以使用"对象名.方法"，推荐使用“类名.方法"

（3）在静态方法中，不能出现：this，也不能直接使用本类的非静态的成员。相反，非静态的实例成员方法可以直接访问静态的类变量或静态方法。

this，非静态的成员，这些都是需要创建对象时，才能使用的，而静态方法调用时，可能没有对象。

小贴士：静态方法只能访问静态成员。

public class Test{
    
    
    public static void main(String[] args){
    
    
    	Son s = new Son();
    	s.fun();//有警告，没错误
    	
    	Son.fun();
    }
}

class Son{
    
    
	private int a;	
	public static void fun(){
    
    
//		method();//错误的
//		System.out.println(a);//错误
//		System.out.println(this.a);//错误

		System.out.println("Son:fun()");
	}
	public void method(){
    
    
		System.out.println("Son:method()");
	}
}

6.6.2 静态变量

static修饰的成员变量，称为类变量、静态变量。

（1）该成员变量的值是该类所有对象共享的

（2）类变量的值和类信息一起存在于方法区中。

（3）它的get/set也是static的，

（4）在static方法中如果有局部变量与类变量重名时，使用“类名.成员变量"进行区别

public class Test{
    
    
    public static void main(String[] args){
    
    
    	Chinese c1 = new Chinese("张三");
    	Chinese c2 = new Chinese("李四");
    	System.out.println("国家名：" + c1.getCountry() + "，姓名：" + c1.getName());
    	System.out.println("国家名：" + c2.getCountry() + "，姓名：" + c2.getName());
    	
    	c1.setCountry("中国");//两个对象共享，一个对象修改，会影响另一个对象
    	System.out.println("国家名：" + c1.getCountry() + "，姓名：" + c1.getName());
    	System.out.println("国家名：" + c2.getCountry() + "，姓名：" + c2.getName());
    	
    	Chinese.setCountry("China");//通过“类名.”访问可读性更好
    	System.out.println("国家名：" + c1.getCountry() + "，姓名：" + c1.getName());
    	System.out.println("国家名：" + c2.getCountry() + "，姓名：" + c2.getName());
    }
}
class Chinese{
    
    
	private static String country = "中华人民共和国";
	private String name;

	public Chinese(String name) {
    
    
		super();
		this.name = name;
	}

	public static String getCountry() {
    
    
		return country;
	}

	public static void setCountry(String country) {
    
    
		Chinese.country = country;//类名.静态变量来区别区别同名变量
	}

	public String getName() {
    
    
		return name;
	}

	public void setName(String name) {
    
    
		this.name = name;
	}
	 
}

在这里插入图片描述

练习

比如说，基础班新班开班，学员报到。现在想为每一位新来报到的同学编学号（sid），从第一名同学开始，sid为1，以此类推。学号必须是唯一的，连续的，并且与班级的人数相符，这样以便知道，要分配给下一名新同学的学号是多少。这样我们就需要一个变量，与单独的每一个学生对象无关，而是与整个班级同学数量有关。

所以，我们可以这样定义一个静态变量numberOfStudent，代码如下：

public class Student {
    
    
  private String name;
  private int age;
  // 学生的id
  private int sid;
  // 类变量，记录学生数量，分配学号
  public static int numberOfStudent = 0;

  public Student(String name, int age){
    
    
    this.name = name;
    this.age = age; 
    // 通过 numberOfStudent 给学生分配学号
    this.sid = ++numberOfStudent;
  }

  // 打印属性值
  public void show() {
    
    
    System.out.println("Student : name=" + name + ", age=" + age + ", sid=" + sid );
  }
}

public class StuDemo {
    
    
  public static void main(String[] args) {
    
    
    Student s1 = new Student("张三", 23);
    Student s2 = new Student("李四", 24);
    Student s3 = new Student("王五", 25);
    Student s4 = new Student("赵六", 26);

    s1.show(); // Student : name=张三, age=23, sid=1
    s2.show(); // Student : name=李四, age=24, sid=2
    s3.show(); // Student : name=王五, age=25, sid=3
    s4.show(); // Student : name=赵六, age=26, sid=4
  }
}

6.6.3 静态导入

JDK1.5引入静态导入

package com.atguigu.test;

import static java.lang.Math.*;

public class Test{
    
    
    public static void main(String[] args){
    
    
    	System.out.println("PI：" + Math.PI);
    	System.out.println("平方根：" + Math.sqrt(4));
    	System.out.println("随机数：" + Math.random());
    	
    	//有静态导入，可以简写如下
    	System.out.println("PI：" + PI);
    	System.out.println("平方根：" + sqrt(4));
    	System.out.println("随机数：" + random());
    }
}

6.6.4 变量的分类与区别详解

1、变量按照数据类型分：

（1）基本数据类型的变量，里面存储数据值

（2）引用数据类型的变量，里面存储对象的地址值

int a = 10;//a中存储的是数据值

Student stu = new Student();//stu存储的是对象的地址值
int[] arr = new int[5];//arr存储的是数组对象的地址值
String str = "hello";//str存储的是"hello"对象的地址值

2、变量按照声明的位置不同：

（1）成员变量

（2）局部变量

class Person{
    
    
	private static String country = "中华人民共和国";//成员变量，静态成员变量,类变量，"中华人民共和国"是常量值
	private String name;成员变量，非静态成员变量，实例变量
	public Person(String name) {
    
    //name 局部变量
		this.name = name;//=左边带this.的是成员变量，=右边没有this.的是局部变量
	}
	public Person() {
    
    
	}
	public static String getCountry() {
    
    
		return country;//成员变量
	}
	public static void setCountry(String country) {
    
    //局部变量
		Person.country = country;//=左边带类名.的是成员变量，=右边是局部变量
	}
	public String getName() {
    
    
		return name;//成员变量
	}
	public void setName(String name) {
    
    //局部变量
		this.name = name;//=左边带this.的是成员变量，=右边是局部变量
	}
}

public class Test{
    
    
    public static void main(String[] args){
    
    //args局部变量
    	String n1 = "张三";//n1局部变量，"张三"是常量值
    	Person p1 = new Person(n1);//p1局部变量
    	
    	String n2 = "李四";//n2局部变量，"李四"是常量值
    	Person p2 = new Person(n2);//p2局部变量
        
        p1.setName("张三丰");//"张三丰"是常量值
    	
    	Person.setCountry("中国");//"中国"是常量值
    }
}

3、成员变量与局部变量的区别

（1）声明的位置不同

成员变量：类中方法外

局部变量：（1）方法的()中，即形参（2）方法体的{}的局部变量（3）代码块{}中

（2）存储的位置不同

成员变量：

如果是静态变量（类变量），在方法区中

如果是非静态的变量（实例变量），在堆中

局部变量：栈

在这里插入图片描述

（3）修饰符不同

成员变量：4种权限修饰符、static等多种修饰符

局部变量：不能有任何修饰符

（4）作用域

成员变量：

如果是静态变量（类变量），在本类中随便用，在其他类中使用“类名.静态变量"

如果是非静态的变量（实例变量），在本类中只能在非静态成员中使用，在其他类中使用“对象名.非静态的变量"

局部变量：有作用域，出了作用域就不能使用

（5）生命周期

成员变量：

如果是静态变量（类变量），和类相同，随着类的加载而分配，随着的类的卸载才消亡。

如果是非静态的变量（实例变量），和所属的对象相同，每一个对象是独立。对象创建时，才在堆中分配内存，随着对象被垃圾回收而消亡。

局部变量：每次方法调用执行都是新的，而且仅在作用域范围内有效。

6.6.5 系统预定义工具类的静态方法

1、数组工具类Arrays

java.util.Arrays数组工具类，提供了很多静态方法来对数组进行操作，而且如下每一个方法都有各种重载形式，以下只列出int[]类型的，其他类型的数组类推：

static int binarySearch(int[] a, int key) ：要求数组有序，在数组中查找key是否存在，如果存在返回第一次找到的下标，不存在返回负数
static int[] copyOf(int[] original, int newLength) ：根据original原数组复制一个长度为newLength的新数组，并返回新数组
static int[] copyOfRange(int[] original, int from, int to) ：复制original原数组的[from,to)构成新数组，并返回新数组
static boolean equals(int[] a, int[] a2) ：比较两个数组的长度、元素是否完全相同
static void fill(int[] a, int val) ：用val填充整个a数组
static void fill(int[] a, int fromIndex, int toIndex, int val)：将a数组[fromIndex,toIndex)部分填充为val
static void sort(int[] a) ：将a数组按照从小到大进行排序
static void sort(int[] a, int fromIndex, int toIndex) ：将a数组的[fromIndex, toIndex)部分按照升序排列
static String toString(int[] a) ：把a数组的元素，拼接为一个字符串，形式为：[元素1，元素2，元素3。。。]

示例代码：

import java.util.Arrays;
import java.util.Random;

public class Test{
    
    
    public static void main(String[] args){
    
    
    	int[] arr = new int[5];
        // 打印数组,输出地址值
  		System.out.println(arr); // [I@2ac1fdc4
  		// 数组内容转为字符串
    	System.out.println("arr数组初始状态："+ Arrays.toString(arr));
    	
    	Arrays.fill(arr, 3);
    	System.out.println("arr数组现在状态："+ Arrays.toString(arr));
    	
    	Random rand = new Random();
    	for (int i = 0; i < arr.length; i++) {
    
    
			arr[i] = rand.nextInt(100);//赋值为100以内的随机整数
		}
    	System.out.println("arr数组现在状态："+ Arrays.toString(arr));
    	
    	int[] arr2 = Arrays.copyOf(arr, 10);
    	System.out.println("新数组：" + Arrays.toString(arr2));
    	
    	System.out.println("两个数组的比较结果：" + Arrays.equals(arr, arr2));
    	
    	Arrays.sort(arr);
    	System.out.println("arr数组现在状态："+ Arrays.toString(arr));
    }
}

2、系统类System的几个方法

系统类中很多好用的方法，其中两个如下：

static long currentTimeMillis() ：返回当前系统时间距离1970-1-1 0:0:0的毫秒值
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：

从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。常用于数组的插入和删除
static void exit(int status) ：退出当前系统
static void gc() ：运行垃圾回收器。

public class Test{
    
    
    public static void main(String[] args){
    
    
    	long time = System.currentTimeMillis();
    	System.out.println("现在的系统时间距离1970年1月1日凌晨：" + time + "毫秒");
    	
    	System.exit(0);

    	System.out.println("over");//不会执行
    }
}

import java.util.Arrays;

public class Test{
    
    
    public static void main(String[] args){
    
    
    	//在[0]插入10
    	int[] arr = {
    
    1,2,3,4,5};
    	//先扩容
    	arr = Arrays.copyOf(arr, arr.length+1);
    	//往后移动元素
    	System.arraycopy(arr, 0, arr, 1, 5);
    	//在[0]插入10
    	arr[0] = 10;
    	System.out.println(Arrays.toString(arr));
    	
    	
    	//删除[0]元素
    	int[] arr2 = {
    
    1,2,3,4,5};
    	//往前移动元素
    	System.arraycopy(arr2, 1, arr2, 0, 4);
    	//最后位置恢复为默认值
    	arr2[arr2.length-1] = 0;
    	System.out.println(Arrays.toString(arr2));
    }
}

3、数学类Math

java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

public static double abs(double a) ：返回 double 值的绝对值。

double d1 = Math.abs(-5); //d1的值为5
double d2 = Math.abs(5); //d2的值为5

public static double ceil(double a) ：返回大于等于参数的最小的整数。

double d1 = Math.ceil(3.3); //d1的值为 4.0
double d2 = Math.ceil(-3.3); //d2的值为 -3.0
double d3 = Math.ceil(5.1); //d3的值为 6.0

public static double floor(double a) ：返回小于等于参数最大的整数。

double d1 = Math.floor(3.3); //d1的值为3.0
double d2 = Math.floor(-3.3); //d2的值为-4.0
double d3 = Math.floor(5.1); //d3的值为 5.0

public static long round(double a) ：返回最接近参数的 long。(相当于四舍五入方法)

long d1 = Math.round(5.5); //d1的值为6.0
long d2 = Math.round(5.4); //d2的值为5.0

public static double pow(double a,double b)：返回a的b幂次方法
public static double sqrt(double a)：返回a的平方根
public static double random()：返回[0,1)的随机值
public static final double PI：返回圆周率
public static double max(double x, double y)：返回x,y中的最大值
public static double min(double x, double y)：返回x,y中的最小值

double result = Math.pow(2,31);
double sqrt = Math.sqrt(256);
double rand = Math.random();
double pi = Math.PI;

练习

请使用Math 相关的API，计算在 -10.8 到5.9 之间，绝对值大于6 或者小于2.1 的整数有多少个？

public class MathTest {
    
    
  public static void main(String[] args) {
    
    
    // 定义最小值
    double min = -10.8;
    // 定义最大值
    double max = 5.9;
    // 定义变量计数
    int count = 0;
    // 范围内循环
    for (double i = Math.ceil(min); i <= max; i++) {
    
    
      // 获取绝对值并判断
      if (Math.abs(i) > 6 || Math.abs(i) < 2.1) {
    
    
        // 计数
        count++;
      }
    }
    System.out.println("个数为: " + count + " 个");
  }
}

Java快速入门—【Java面向对象】—09

面向对象基础–中

今日内容

教学目标

第六章面向对象基础–中

6.1 封装

6.1.1 封装概述

6.1.2 属性的封装

原则

属性封装的目的

实现步骤

6.1.3 权限修饰符

练习1

6.2 构造器（Constructor)

构造器的作用

构造方法的定义格式

注意事项

练习

6.3 this关键字

this的含义

this使用格式

练习

6.4 标准JavaBean

6.5 包（Package）

6.5.1 包的作用

6.5.2 声明包的语法格式

6.5.3 如何编译和运行（了解，之后在idea中就不用了）

6.5.4 使用其他包的类

6.6 static

6.6.1 静态方法

6.6.2 静态变量

练习

6.6.3 静态导入

6.6.4 变量的分类与区别详解

6.6.5 系统预定义工具类的静态方法

1、数组工具类Arrays

2、系统类System的几个方法

3、数学类Math

练习

猜你喜欢

Java快速入门—【Java面向对象】—09

面向对象基础–中

今日内容

教学目标

第六章 面向对象基础–中

6.1 封装

6.1.1 封装概述

6.1.2 属性的封装

原则

属性封装的目的

实现步骤

6.1.3 权限修饰符

练习1

6.2 构造器（Constructor)

构造器的作用

构造方法的定义格式

注意事项

练习

6.3 this关键字

this的含义

this使用格式

练习

6.4 标准JavaBean

6.5 包（Package）

6.5.1 包的作用

6.5.2 声明包的语法格式

6.5.3 如何编译和运行（了解，之后在idea中就不用了）

6.5.4 使用其他包的类

6.6 static

6.6.1 静态方法

6.6.2 静态变量

练习

6.6.3 静态导入

6.6.4 变量的分类与区别详解

6.6.5 系统预定义工具类的静态方法

1、数组工具类Arrays

2、系统类System的几个方法

3、数学类Math

练习

猜你喜欢

第六章面向对象基础–中