API常用类的概述

API概述

常用类

Object类/Scanner类

String类/StringBuffer类/StringBuilder类

数组高级和Arrays类

基本类型包装类(Integer,Character)

正则表达式(Pattern,Matcher)

Math类/Random类/System类

BigInteger类/BigDecimal类

Date类/DateFormat类/Calendar类

 

 

 

API概述

API(Application Programming Interface)

应用程序编程接口

编写一个机器人程序去控制机器人踢足球，程序就需要向机器人发出向前跑、向后跑、射门、抢球等各种命令，没有编过程序的人很难想象这样的程序如何编写。但是对于有经验的开发人员来说，知道机器人厂商一定会提供一些用于控制机器人的Java类，这些类中定义好了操作机器人各种动作的方法。其实，这些Java类就是机器人厂商提供给应用程序编程的接口，大家把这些类称为Xxx Robot API。本章涉及的Java API指的就是JDK中提供的各种功能的Java类。

 

Java API就是Java提供给我们使用的类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。

我们可以通过查帮助文档来了解Java提供的API如何使用

 

 

学习汉语和学习编程的异同点

相同点

  基本语法

  大量成语

  写文章的手法和技巧

不同点

  学习汉语  必须先学后用

  学习编程  可以现用现学

 

 

 

 

Object类概述及其构造方法

Object类概述

   类层次结构的根类

    所有类都直接或者间接的继承自该类

构造方法

  public Object()

  回想面向对象中为什么说：

  子类的构造方法默认访问的是父类的无参构造方法

 

hashCode() 与  getClass()

public int hashCode()

A:返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。

B:不同对象的，hashCode()一般来说不会相同。

  但是，同一个对象的hashCode()值肯定相同。

C:不是对象的实际地址值，可以理解为逻辑地址值。

举例：物体和编号。

 

 

package cn.it18zhang_01;

 

/*

 * Object:类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。

 * 每个类都直接或者间接的继承自Object类。

 *

 * Object类的方法：

 * public int hashCode():返回该对象的哈希码值。

 * 注意：哈希值是根据哈希算法计算出来的一个值，这个值和地址值有关，但是不是实际地址值。

 *            你可以理解为地址值。

 *

 *public final Class getClass():返回此 Object 的运行时类

 *Class类的方法：

 *public String getName()：以 String 的形式返回此 Class 对象所表示的实体

 */

public class StudentTest {

public static void main(String[] args) {

Student s1 = new Student();

System.out.println(s1.hashCode()); // 11299397

Student s2 = new Student();

System.out.println(s2.hashCode());// 24446859

Student s3 = s1;

System.out.println(s3.hashCode()); // 11299397

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

 

Student s = new Student();

Class c = s.getClass();

String str = c.getName();

System.out.println(str); // cn.it18zhang_01.Student

//链式编程

String str2  = s.getClass().getName();

System.out.println(str2);

}

}

 

package cn.it18zhang_01;

 

public class Student extends Object {

 

}

 

 

public String toString()

A:返回该对象的字符串表示。

底层源码。

public static String valueOf(Object obj) {

         return (obj == null) ? "null" : obj.toString();

     }

B:它的值等于：

getClass().getName() + '@' + Integer.toHexString(hashCode())

C:由于默认情况下的数据对我们来说没有意义，一般建议重写该方法。

a:手动重写

b:自动生成

 

 

 

 

 

 

 

package cn.it18zhang_02;

 

public class Student {

private String name;

private int age;

 

public Student() {

super();

}

 

public Student(String name, int age) {

super();

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;

}

 

@Override

public String toString() {

return "Student [name=" + name + ", age=" + age + "]";

}

 

// @Override

// public String toString() {

// // return super.toString();

// // return "hello";

// return "姓名:" + name + ",年龄:" + age;

// }

}

 

 

package cn.it18zhang_02;

 

/*

 * public String toString():返回该对象的字符串表示。

 *

 * Integer类下的一个静态方法：

 * public static String toHexString(int i)：把一个整数转成一个十六进制表示的字符串

 *

 * 这个信息的组成我们讲解完毕了，但是这个信息是没有任何意义的。所以，建议所有子类都重写该方法。

 * 怎么重写呢?

 * 把该类的所有成员变量值组成返回即可。

 * 重写的最终版方案就是自动生成toString()方法。

 *

 * 注意：

 *  直接输出一个对象的名称，其实就是调用该对象的toString()方法。

 */

public class StudentDemo {

public static void main(String[] args) {

Student s = new Student();

System.out.println(s.hashCode());

System.out.println(s.getClass().getName());

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

System.out.println(s.toString());// cn.it18zhang_02.Student@42552c

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

// toString()方法的值等价于它

// getClass().getName() + '@' + Integer.toHexString(hashCode())

// this.getClass().getName()+'@'+Integer.toHexString(this.hashCode())

 

// cn.it18zhang_02.Student@42552c

// cn.it18zhang_02.Student@42552c

 

System.out.println(s.getClass().getName() + '@'

+ Integer.toHexString(s.hashCode()));

 

System.out.println(s.toString());

 

// 直接输出对象的名称

System.out.println(s);

}

}

 

public boolean equals(Object obj)

A:指示其他某个对象是否与此对象“相等”。

B:默认情况下比较的是对象的引用是否相同。

C:由于比较对象的引用没有意义，一般建议重写该方法。

a:手动重写

b:自动生成

 

package cn.it18zhang_03;

 

public class Student {

private String name;

private int age;

 

public Student() {

super();

}

 

public Student(String name, int age) {

super();

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;

}

 

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())

return false;

Student other = (Student) obj;

if (age != other.age)

return false;

if (name == null) {

if (other.name != null)

return false;

} else if (!name.equals(other.name))

return false;

return true;

}

//@Override

//public boolean equals(Object obj) {

//// return true;

////这里要改进，根据这里比较的成员变量来决定返回true还是false

////这里其实要比价的就是name和age

////但是，name是String类型的，而String是引用类型的，所以，在这里不能直接用==比较，应该用equals()比较

////String的equals()方法是重写自Object类的，比较的是字符串的内容是否相同

////this -- s1

////obj -- s2

////我们要使用的是学生类的特有成员变量,所以要向下转型

//Student s = (Student)obj; //s -- obj -- s2;

//if(this.name.equals(s.name) && this.age == s.age) {

//return true;

//}else {

//return false;

//}

//}

//@Override

//public boolean equals(Object obj) {

////为了提高效率

//if(this == obj){

//return true;

//}

//

////为了提供程序的健壮性

////我先判断一下，obj是不是学生的一个对象，如果是，再做向下转型，如果不是，直接返回false。

////这个时候，我们要判断的是对象是否是某个类的对象?

////记住一个格式：对象名 instanceof 类名

////表示：判断该对象名是否是该类名一个对象

//if(!(obj instanceof Student)){

//return false;

//}

////如果是就继续

//

//Student s = (Student)obj;

////System.out.println("同一个对象，还需要向下转型并比较吗?");

//return this.name.equals(s.name) && this.age == s.age;

//}

}

 

 

 

protected void finalize()

A:当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

B:垃圾回收器不会马上回收垃圾，但是我们可以建议它尽快回收垃圾。(System.gc()方法)

C:主要针对堆内存。

 

 

protected Object clone()

创建并返回此对象的一个副本，这种克隆机制十分高效，而且二者之间完全隔离。

自定义类实现克隆步骤：

A:自定义类实现Cloneable接口，这是一个标记性接口，实现这个接口的类的对象可以实现自我克隆。

B:自定义类中重写Object类的clone()方法。

C:重写clone()方法时通过super.clone()调用Object类的clone()方法来得到该对象的副本，并返回该副本。

 

package cn.it18zhang_04;

 

public class Student implements Cloneable {

private String name;

private int age;

 

public Student() {

super();

}

 

public Student(String name, int age) {

super();

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;

}

@Override

protected Object clone() throws CloneNotSupportedException {

return super.clone();

}

}

 

 

package cn.it18zhang_04;

 

/*

 *protected void finalize()：当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。用于垃圾回收，但是什么时候回收不确定。

 *protected Object clone():创建并返回此对象的一个副本。

 *A:重写该方法

 *

 *  Cloneable:此类实现了 Cloneable 接口，以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制。

 *  这个接口是标记接口，告诉我们实现该接口的类就可以实现对象的复制了。

 */

public class StudentDemo {

public static void main(String[] args) throws CloneNotSupportedException {

//创建学生对象

Student s = new Student();

s.setName("林青霞");

s.setAge(27);

//克隆学生对象

Object obj = s.clone();

Student s2 = (Student)obj;

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

System.out.println(s.getName()+"---"+s.getAge());

System.out.println(s2.getName()+"---"+s2.getAge());

//以前的做法

Student s3 = s;

System.out.println(s3.getName()+"---"+s3.getAge());

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

//其实是有区别的

s3.setName("張長志");

s3.setAge(30);

System.out.println(s.getName()+"---"+s.getAge());

System.out.println(s2.getName()+"---"+s2.getAge());

System.out.println(s3.getName()+"---"+s3.getAge());

}

}