java学习-day11-接口(二). API(一)-Object.String

接口的复杂用法

实现类可以同时使用多个接口

注：要求实现类重写多个接口里的所有抽象方法,否则就是一个抽象类

// 测试 接口 的多实现:是指实现 类和接口 的关系,实现类可以同时使用多个接口
public class Test1 {
	public static void main(String[] args) {	
	}
}
interface Inter1{
	void save();
	void delete();
}
interface Inter2{
	void get();
}
// 创建实现类,同时使用1号和2号接口,多个接口间逗号隔开,
//要求实现类重写多个接口里的所有抽象方法,否则就是一个抽象类
class InterImpl implements Inter1,Inter2{
	@Override
	public void get() {
		System.out.println("get()...");
	}
	@Override
	public void save() {
		System.out.println("save()...");
	}
	@Override
	public void delete() {
		System.out.println("delete()...");
	}
}

接口与接口间可以发生继承关系，还可以多继承

// 测试 接口 多继承:突破了java 单继承的局限性,是指接口与接口间的关系
public class Test2 {
	public static void main(String[] args) {	
	}
}
interface Inter3{
	void get();
	void delete();
}
interface Inter5{
	void select();
}
// 接口和接口间,可以发生继承关系,还可以多继承
interface Inter4 extends Inter3,Inter5{
	void update();
}
class InterImpl2 implements Inter4{
	@Override
	public void get() {
		System.out.println("get()...");
	}
	@Override
	public void delete() {
		System.out.println("delete()...");
	}
	@Override
	public void update() {
		System.out.println("update()...");
	}
	@Override
	public void select() {
		System.out.println("select()...");
	}	
}

实现类 可以 在单继承的同时 多实现

子类 extends 父类 implements 接口1,接口2,…

// 测试  实现类可以单继承 的同时多实现
public class Test3_ManyExtedns3 {
	public static void main(String[] args) {
		Inter6 in = new Zi();
		in.save();
	}
}
interface Inter6{
	void save();
}
interface Inter7{
	void delete();
}
abstract class Fu{
	abstract public void print();
	public void get(){
		System.out.println("get()...");
	}
}
// 作为实现类,可以单继承的同时多实现
class Zi extends Fu implements Inter6,Inter7{
	public void save(){
		System.out.println("save()...");
	}
	public void delete(){
		System.out.println("delete()...");
	}
	public void print(){
		System.out.println("print()...");
	}
}

关于类和接口的部分总结

1、类和类之间的关系：继承，而且是单继承
– class Zi extends Fu
– Zi是子类 单继承 Fu是父类
– 让子类继承父类，子类就拥有了父类的所有功能(除了private,构造方法)
– 方法重写override，要求是子类的方法声明和父类一样，改的是方法体,且访问权限符大于等于父类方法
– super可以在子类中使用，用来调用父类的功能，代表的是父类对象的引用
2、接口和接口之间的关系： 继承，而且可以多继承(逗号隔开)
– interface Inter1 extends Inter2
– 其中，Inter1子接口 ， inter2父接口，此时Inter1拥有inter2的所有功能
–interface inter3 extends Inter2 , Inter1
– 其中，inter3也是接口，可以同时使用Inter2 和 Inter1 的功能
– 为了突破java单继承的局限性而来
3、实现类和接口之间的关系：实现，而且可以多实现(逗号隔开)
– class InterImpl implements Inter1
– 其中，InterImpl是实现类，Inter1是接口
– 此时，InterImpl拥有接口里的所有功能，并且需要重写所有抽象方法，否则就是抽象类
– class InterImpl implements Inter1 , Inter2
– 其中，InterImpl实现了Inter1和Inter2的所有功能，重写所有抽象方法，否则还是抽象类
– class InterImpl extends Fu implements Inter1 , Inter2
– 其中，InterImpl继承了Fu类的功能，同时拥有了Inter1和Inter2的所有功能
– 要求InterImpl重写所有抽象方法，否则就是抽象类
4、接口和抽象类的区别
– 抽象类是一个特殊的类，特殊在抽象类中可以有普通方法和 抽象方法
– 接口是一个特殊的抽象类，特殊在接口里都是 抽象方法
– 语法上的区别：
– 接口里没有构造方法，抽象类里有
– 接口里没有变量，抽象类里有
– 接口里的常量和方法都可以简写，抽象类不能简写
– 接口和实现类是实现关系，抽象类和子类是继承关系
– 定义接口和定义抽象类用的关键字不同

API

Application Programming Interface应用编程接口
一切可以调用的东西都是API。
未来几天内容都参考 JAVA JDK API 1.6.0 中文手册

Object

Object 是一切类的 超类，Object 是类层次结构的 根类。因此我们定义的所有类都继承了该类的方法
Object 常用方法：
toString() 返回该对象的字符串表示
hashCode() 返回该对象的哈希码值
equals(Object object) 指示其他某个对象是否与此类“相等”
注：调用 print() 方法时，底层会调用该方法：

public static String valueOf(Object obj) {
        return (obj == null) ? "null" : obj.toString();
    }

即 默认 调用 对象的 toString() 方法，toString()方法是从 Object 类继承过来的，是打印的地址值，若想打印对象的
属性值，需对 toString()方法进行重写。(Eclispse工具可为我们自动生成)

// 测试 Object 工具类
// toString():默认使用的是Object里的,也就是打印地址值,如果想查看属性值,需要重写 toString()方法
// hashCode():获取对象在内存中的哈希码值
// equals(): 如果比较的是对象的地址值,直接使用默认的 Object提供的就可以,但如果要比较属性值就需要重写 
public class Test4 {
	public static void main(String[] args) {
		Student student = new Student("jack",25,"China",78);
//		System.out.println(student.getName()+student.getAge()+student.getAddr()+student.getScore());
//		System.out.println(student.toString()); // cn.tedu.api.Student@15db9742
		System.out.println(student);
		System.out.println(student.hashCode()); // 返回对象在内存中的哈希码值S
		System.out.println("对象的地址值是:"+ Integer.toHexString(student.hashCode()));//模拟对象的地址值的获取
		
		// equals() 比较两个对象是否相等
		Student student2 = new Student("jack",25,"China",78);
		//默认使用了Object提供的equals() 使用==比较
		// == 比较引用变量时,比较的是地址值
		// == 比较基本类型变量时,比较的是数值
		System.out.println(student.equals(student2));// 重写前false,比较的是对象的地址值.重写后true	
	}
}
class Student{
	public Student(){}
	public Student(String name, int age, String addr, double score) {
		// 创建对象时,给对象赋值
		super();
		this.name = name;
		this.age = age;
		this.addr = addr;
		this.score = score;
	}
	// 封装属性
	private String name;
	private int age;
	private String addr;
	private double score;
	// 提供全局访问点 右键-source-getters and setters -select all - ok
	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 String getAddr() {
		return addr;
	}
	public void setAddr(String addr) {
		this.addr = addr;
	}
	public double getScore() {
		return score;
	}
	public void setScore(double score) {
		this.score = score;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", addr=" + addr + ", score=" + score + "]";
	}
	//重写 equals():因为默认使用Object的 equals()比较的是对象的地址值
	@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 (addr == null) {
			if (other.addr != null)
				return false;
		} else if (!addr.equals(other.addr))
			return false;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (Double.doubleToLongBits(score) != Double.doubleToLongBits(other.score))
			return false;
		return true;
	}
//	@Override
//	public boolean equals(Object obj){
//		//要求参数 obj 必须是学生类型
//		Student s = (Student) obj; // 向下转型
//		if(this.name==s.name && this.age==s.age
//				&& this.addr==s.addr && this.score==s.score){
//			return true;
//		}
//		return false;
//		
//	}	
}

String 类

String 类表示字符串
注：字符串是常量，值在创建之后不能被修改。
常用构造方法：

String s = "abc";
String(char[] value) 
String(byte[] bytes) 

常用使用方法：

char charAt(int index) 

返回指定索引处的 char 值。

String concat(String str) 

将指定字符串连接到此字符串的结尾。

boolean endsWith(String suffix) 

测试此字符串是否以指定的后缀结束。

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

boolean equals(Object anObject) 

将此字符串与指定的对象比较。

byte[] getBytes() 

使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。

int hashCode() 

返回此字符串的哈希码。

int indexOf(String str) 

返回指定子字符串在此字符串中第一次出现处的索引。

	int lastIndexOf(String str) 

返回指定子字符串在此字符串中最右边出现处的索引。

	int length() 

返回此字符串的长度。

String replace(char oldChar, char newChar) 

返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。

String[] split(String regex) 

根据给定正则表达式的匹配拆分此字符串

boolean startsWith(String prefix) 

测试此字符串是否以指定的前缀开始。

String substring(int beginIndex) 

返回一个新的字符串，它是此字符串的一个子字符串。

String substring(int beginIndex, int endIndex) 

返回一个新字符串，它是此字符串的一个子字符串。

String toLowerCase() 

使用默认语言环境的规则将此 String 中的所有字符都转换为小写。

String toUpperCase() 

使用默认语言环境的规则将此 String 中的所有字符都转换为大写。

String trim() 

返回字符串的副本，忽略前导空白和尾部空白。

static String valueOf(long l) 

返回 long 参数的字符串表示形式。

import java.util.Arrays;
// 测试 String 工具类
public class Test5_String {
	public static void main(String[] args) {
		//1.创建 字符串 对象 
		char[] chars = {'a','b','c'};
		String str = new String(chars);		
		byte[] bytes = {97,98,99};
		String str2 = new String(bytes);
		String str3 = "abc";
		//2.调用常用方法
//		char c = str.charAt(2);//获取指定下标对应的字符
//		System.out.println(c);
		System.out.println(str.charAt(2));//c  获取指定下标对应的字符
		System.out.println(str.concat("哈哈"));//abc哈哈 相当于拼接字符串
		System.out.println(str.endsWith("c"));//true 判断是否以指定字符结束
		System.out.println(str=="abc");// false 比较的是地址值
		System.out.println(str.equals("abc"));//true String已经重写了equals()方法
		System.out.println();
		System.out.println(str.getBytes());//[B@15db9742 用来把数据存入byte数组
		System.out.println(str.hashCode());//96354 获取对象在内存中的哈希码值
		System.out.println(str.indexOf("a"));//0 返回指定数据在字符串中第一次出现的下标
		str = "abcbca";//真的把字符串str的值改掉了吗？
		System.out.println(str.lastIndexOf("a"));//5 返回指定数据在字符串中最后一次出现的下标
		System.out.println(str.length());//6 获取字符串的长度
		System.out.println();
		System.out.println(str.replace('a','x'));//xbcbcx 把字符串中出现的所有 a 字符 替换成 x字符
		str = "a0Bc";
		System.out.println(Arrays.toString(str.split("0")));//[a, Bc] 按照指定数据切割字符串
		System.out.println(str.startsWith("a"));//true 判断是否以指定数据开始
		System.out.println(str.substring(1));//0Bc 从指定下标处开始,向后截取所有字符串[1,n]
		System.out.println(str.substring(0,2));//a0 从指定下标处开始 到 指定处结束,但是 左闭又开 
		System.out.println();
		System.out.println(str.toLowerCase());//a0bc 把字符串中的所有数据转成小写
		System.out.println(str.toUpperCase());//A0BC 把字符串中的所有数据转成大写
		str = "   a0B    c        ";
		System.out.println(str.trim());//a0B    c 去除前导多余空格和后导多余空格
		System.out.println(String.valueOf(9.9)+ 1);//9.91 把其他类型转成String类型
	}
}