2021-04-15

一，接口
–1，测试
package cn.tedu.oop;
//测试 接口
public class Test1 {
public static void main(String[] args) {
//第三步,创建多态对象测试
// new A();//1,接口和抽象类一样,都不能new
A a = new B();//统一调用标准/多态/向上造型
//多态里,只能调用左边的功能
a.show1();
a.show2();
}
}
//第一步,通过关键字interface创建接口
interface A{
//1，接口是一个特殊的抽象类，因为接口里都是抽象方法
abstract public void show1();
abstract public void show2();
}
//第二步,创建实现类,实现接口
//1,实现类需要 重写所有的抽象方法,否则,包含着抽象方法是一个抽象类
//abstract class B implements A{
class B implements A{
public void show1() {
System.out.println(1);
}
public void show2() {
System.out.println(2);
}
}
二，接口的使用
–1，测试
package cn.tedu.oop;
//测试 接口的使用
//总结：
//1,接口是一个特殊的抽象类,特殊在 接口里的方法都是抽象方法
//2,接口没有构造方法,没有变量.有常量(可以简写)
//+有抽象方法(可以简写)+有普通方法(jdk1.8)
//3,实现类实现了接口,需要重写所有的抽象方法,否则是一个抽象类
//4,实现类必须要重写普通方法吗?–想改才重写普通方法
//5,接口的常量可以简写:int a = 10;会自动拼接public static final
//6,接口的抽象方法可以简写:void show();会自动拼接public abstract
//7,接口不能new/实例化
//8,接口突破了java单继承的局限性,可以多继承,多实现,继承时多实现
public class Test2 {
public static void main(String[] args) {
Inter in = new InterImpl();
//in.age = 20; //age是final的
System.out.println( in.age );
System.out.println( Inter.age );//age是static的
}
}
interface Inter{
//TODO Constructor…
//public Inter() {} //1,接口里没有构造方法

		//TODO Field..
		int age = 10; //2,接口里没有变量，都是常量(可以简写)
		//接口会为简写的常量，自动拼接public static final
		//public static final int age = 10;
		
		//TODO Method..
		void show1();//3,接口里的抽象方法可以简写
		//接口会为简写的抽象方法，自动拼接public abstract
	//	abstract public void show1();
	//4,接口里有普通方法吗--jdk1.8提供的新语法可以有,必须是default/static
		default void show2(){ 	}
		static void show3() { 	}
	}
	//5,实现类实现了接口以后，需要重写 抽象方法，否则是一个抽象类
	class InterImpl implements Inter{
	//	void show1(); 
		@Override
		public void show1() {
			System.out.println(1);
		}
	}

三，接口的复杂用法
–1，概述
接口和类之间可以多实现，接口和接口之间可以多继承
–2，测试
package cn.tedu.oop;

	import java.io.Serializable;
	import java.util.Collection;
	import java.util.Iterator;

	//测试 接口的复杂使用
	public class Test3 {
		public static void main(String[] args) {
			
		}
	}
	interface A1{
		void save();
	}
	interface A2{
		void get(int id);
	}
	//1,接口突破了java单继承的局限性。接口间可以发生多 继承关系。
	interface A3 extends A1,A2{
		void del();
	}
	//3,实现类 可以在继承的同时 多实现,实现类必须重写所有的抽象方法，否则是一个抽象类
	class Impl extends Object implements A1,A2 {
		@Override
		public void get(int id) { }
		@Override
		public void save() { }
	}
	//2,实现类和接口是 实现关系,可以多实现。
	//必须重写 所有抽象方法，否则就是一个抽象类
	class AImpl implements A1,A2,A3{
		@Override
		public void del() { }
		@Override
		public void get(int id) { }
		@Override
		public void save() { }
	}
	//TODO 练习：使用存在的接口Collection和Serializable
	//abstract class Demo implements Collection{
	class Demo implements Collection,Serializable{
	//重写所有抽象方法
		@Override
		public int size() {
			// TODO Auto-generated method stub
			return 0;
		}

		@Override
		public boolean isEmpty() {
			// TODO Auto-generated method stub
			return false;
		}

		@Override
		public boolean contains(Object o) {
			// TODO Auto-generated method stub
			return false;
		}

		@Override
		public Iterator iterator() {
			// TODO Auto-generated method stub
			return null;
		}

		@Override
		public Object[] toArray() {
			// TODO Auto-generated method stub
			return null;
		}

		@Override
		public Object[] toArray(Object[] a) {
			// TODO Auto-generated method stub
			return null;
		}

		@Override
		public boolean add(Object e) {
			// TODO Auto-generated method stub
			return false;
		}

		@Override
		public boolean remove(Object o) {
			// TODO Auto-generated method stub
			return false;
		}

		@Override
		public boolean containsAll(Collection c) {
			// TODO Auto-generated method stub
			return false;
		}

		@Override
		public boolean addAll(Collection c) {
			// TODO Auto-generated method stub
			return false;
		}

		@Override
		public boolean removeAll(Collection c) {
			// TODO Auto-generated method stub
			return false;
		}

		@Override
		public boolean retainAll(Collection c) {
			// TODO Auto-generated method stub
			return false;
		}

		@Override
		public void clear() {
			// TODO Auto-generated method stub
			
		}
		
	}

四，Object
–1,测试
package cn.tedu.api;
//测试 Object工具类
public class Test4 {
public static void main(String[] args) {
//1,创建对象
Object o = new Object();//触发无参 构造
//2,调用方法
String a = o.toString();//返回该对象的字符串表示
System.out.println(a);//java.lang.Object@15db9742
System.out.println( o.toString() );

	//      int hashCode()   返回该对象的哈希码值。 
			System.out.println( o.hashCode() );//366712642
			
	//      boolean equals(Object obj)
			boolean b = o.equals("jack"); //某个对象是否与此对象“相等”。 
			System.out.println(b);//false
		}
	}


--2,复杂测试
	--创建Student类
		package cn.tedu.api;
		//总结:
		//1,重写toString()--不想用Object提供的打印地址值,而是想打印属性值
		//2,重写equals()--不想用Object提供的比较地址值,而是想要比较属性值
		//右键-source-toString()/equals()/get/set/constructor...
		public class Student extends Object {
			//TODO Fields...
			private String name;
			private int age;
			//TODO Constructors...右键-source-倒数第三个-ok
			public Student() { }
			public Student(String name, int age) {
				//给成员变量赋值
				this.name = name;
				this.age = age;
			}
			//TODO getters...
			public String getName() {
				return name;
			}
			public int getAge() {
				return age;
			}
		//需求2:比较时,不比较地址值,而比较属性值--重写equals()
		//如果属性值都一样,就是同一个对象,就让equals()返回true
			@Override
			public boolean equals(Object obj) {
				if (this == obj)
					return true;
				if (obj == null)
					return false;
				if (getClass() != obj.getClass())
					return false;
				//1,统一比较的类型
				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;
				//2,比属性值,如果属性值都一样,就直接返回true
				return true;
			}
			
		//需求1:打印时,不想打印地址值,而是想要打印属性值--继承Object重写toString()
			//右键-source-倒数第四个-ok
			@Override
			public String toString() {
				return "Student [name=" + name + ", age=" + age + "]";
			}
			
			
		}

	--创建测试类
		package cn.tedu.api;
		//测试 Object工具类的复杂用法
		public class Test5 {
			public static void main(String[] args) {
				//TODO 创建学生对象
				Student s = new Student("杨幂",25);
		//打印s时,底层自动调用了toString(),不重写就用Object的,重写了就用子类的
		//1,需求:打印时,不想打印地址值,而是想要打印属性值--继承Object重写toString()
		//重写前:cn.tedu.api.Student@15db9742,重写后:Student [name=杨幂, age=25]
				System.out.println(s);
				
				Student s2 = new Student("杨幂",25);
		//equals()用了父类Object的,Object就是用了==比，比了s和s2的地址值
		//2,需求:比较时,不比较地址值,而比较属性值,
				//如果属性值都一样,就是同一个对象,就让equals()返回true
				//重写equals()
				boolean b = s.equals(s2);
		//重写前:比了地址值,得到false,重写后:比了属性值,得到了true
				System.out.println(b);
				
			}
		}

五，String
–1，概述
String 类代表字符串。Java 程序中的所有字符串字面值（如 “abc” ）都作为 此类的实例实现。 字符串是常量；它们的值在创建之后不能更改。
–2，构造方法
String()
String(char[] value)
分配一个新的 String，使其表示字符数组参数中当前包含的字符序列
–3,测试
package cn.tedu.api;
//测试 String工具类
public class Test6 {
public static void main(String[] args) {
//1，创建对象
String s = new String();//触发无参构造

			char[] value = {'h','e','l','l','o'} ;
			String s2 = new String(value);//触发含参构造
			
			//2，调用方法
	//		char charAt(int index) 
			char a = s2.charAt(0);//根据下标0获取对应的字符h
			System.out.println(a);
	//		String concat(String str) 
			String b = s2.concat("123");//拼接字符串
			System.out.println(b);//hello123
	//		boolean endsWith(String suffix) 
			boolean c = s2.endsWith("lo");//判断s2是否以"lo"结尾
			System.out.println(c);//true
			
			//TODO 调用以下方法
	//		 boolean contains(CharSequence s) 
	//		 boolean endsWith(String suffix)  
	//		 boolean equals(Object anObject)  
	//		 int hashCode()  
	//		 int indexOf(String str)
	//		 int lastIndexOf(String str)  
	//		 boolean isEmpty()  
	//		 int length()  
	//		 boolean matches(String regex)  
	//		 String replace(char oldChar, char newChar)  
	//		 boolean startsWith(String prefix)  
	//		 String substring(int beginIndex)  
	//		 String substring(int beginIndex, int endIndex)  
	//		 String toLowerCase()  
	//		 String toUpperCase()  
	//		 String trim()  
	//		 static String valueOf(double d) 
	//		 byte[] getBytes() 
	//		 String[] split(String regex)  
	//		 char[] toCharArray()  
		}
	}

扩展：
–1，接口和抽象类的区别