常用类

一.Object

含义：

所有类的基类/超类，一个类没有明确继承的类，默认继承Object

1.equals

比较两个对象内存地址是否相同

源码实现：

public boolean equals(Object obj){
    return this == obj;
}

代码实现：

public static void main(String[] args) {
    
    Object obj1 = new Object();//0x001
    Object obj2 = new Object();//0x002

    boolean equals = obj1.equals(obj2);
    System.out.println(equals);//false

    boolean bool = obj1 == obj2;
    System.out.println(bool);//false

}

2.getClass

获取该类的字节码文件对象

代码实现：

public static void main(String[] args) {
    
    Object obj1 = new Object();//0x001
    Object obj2 = new Object();//0x002

    Class<? extends Object> c1 = obj1.getClass();
    Class<? extends Object> c2 = obj2.getClass();

    System.out.println(c1 == c2);//true

}

//应用于反射，实现获得类的字节码文件对象后获取类中的属性和方法.
public static void main(String[] args) {
		
    A a = new A();

    //获取A类的字节码文件对象
    Class<? extends A> c = a.getClass();

    //获取A类中所有属性
    Field[] declaredFields = c.getDeclaredFields();
    for (Field field : declaredFields) {
        System.out.println(field);
    }

    //获取A类中所有的方法
    Method[] declaredMethods = c.getDeclaredMethods();
    for (Method method : declaredMethods) {
        System.out.println(method);
    }

}

3.hashCode

获取对象的hash值
hash值=系统利用对象的内存地址+散列算法获取的一个值
注意：hash值不等于内存地址

代码实现：

public static void main(String[] args) {

    Object obj1 = new Object();
    Object obj2 = new Object();

    System.out.println(obj1.hashCode());
    System.out.println(obj2.hashCode());
}

4.toString

获取对象的字符串表示（将对象转换为字符串）

源码实现：

public String toString(){
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

代码实现：

public static void main(String[] args) {

    Object obj1 = new Object();

    //java.lang.Object@15db9742
    System.out.println(obj1.toString());
    
}

二.Object标杆作用

1.equals

判断两个对象是否相同，Object不同的子类判断两个的对象是否相同有不同的判断规则，子类重写equals即可

代码实现：

public static void main(String[] args) {

    User user1 = new User("1445584980", "123123");
    User user2 = new User("1445584980", "123123");

    System.out.println(user1.equals(user2));//重写toStrong方法后输出true

    System.out.println(user1);//默认调用toString

}
package com.dream.test02;

public class User {
	
	private String username;
	private String password;

	public User() {
	}

	public User(String username, String password) {
		this.username = username;
		this.password = password;
	}

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}
	
	@Override
	public boolean equals(Object obj) {
		if(this == obj){
			return true;
		}
		
		User user = (User) obj;
		if(this.username.equals(user.username)){
			return true;
		}
		return false;
	}
	
	@Override
	public String toString() {
		return username + " -- " + password;
	}
}

2.toString

返回对象的字符串表示，Object不同的子类有不同的属性，重写toString，返回属性

需求：

public static void main(String[] args) {
     //需求：
     //两个学生班级号+学号一样视作同一学生
     //打印学生对象：把该学生所有的属性都打印出来
    Student stu1 = new Student("春日野结衣", '女', 18, "2107", "001");
    Student stu2 = new Student("卢永刚", '男', 21, "2107", "001");

    System.out.println(stu1.equals(stu2));//true

    System.out.println(stu1);//春日野结衣--女--18--2107--001
}

public class Student {
	
	private String name;
	private char sex;
	private int age;
	private String classId;
	private String id;
	
	public Student() {
	}

	public Student(String name, char sex, int age, String classId, String id) {
		this.name = name;
		this.sex = sex;
		this.age = age;
		this.classId = classId;
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

	public char getSex() {
		return sex;
	}

	public void setSex(char sex) {
		this.sex = sex;
	}

	public int getAge() {
		return age;
	}

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

	public String getClassId() {
		return classId;
	}

	public void setClassId(String classId) {
		this.classId = classId;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}
	
	@Override
	public boolean equals(Object obj) {
		if(this == obj){
			return true;
		}
		
		Student stu = (Student) obj;
		if(this.classId.equals(stu.classId) && this.id.equals(stu.id)){
			return true;
		}
		return false;
	}

	@Override
	public String toString() {
		return "name=" + name + ", sex=" + sex + ", age=" + age + ", classId=" + classId + ", id=" + id;
	}
}

三.String底层源码

String的equals为什么可以判断字符串内容？
底层把String的内容转换为字符数组，依次比较ASCII码

代码实现：

package com.dream.test02;

public class Test03 {

	public static void main(String[] args) {
		
		String str1 = new String("abc");
		String str2 = new String("abc");
		System.out.println(str1 == str2);//false
		System.out.println(str1.equals(str2));//true - 比较两个字符串内容是否相同
		System.out.println(str1);//默认调用toString
		System.out.println(str2);//默认调用toString
		
		System.out.println("--------------");
		
		MyString m1 = new MyString("abc");
		MyString m2 = new MyString("abc");
		System.out.println(m1 == m2);//false
		System.out.println(m1.equals(m2));
		System.out.println(m1);
		System.out.println(m2);
		
	}
}
package com.dream.test02;

public class MyString {
	
	private String value;

	public MyString(String value) {
		this.value = value;
	}
	
	@Override
	public boolean equals(Object obj) {
		if(this == obj){
			return true;
		}
		
		MyString m = (MyString) obj;
		
		//['a','b','c']
		char[] v1 = this.value.toCharArray();//把当前对象的str转换为字符数组
		//['a','b','c']
		char[] v2 = m.value.toCharArray();//把当前对象的str转换为字符数组
		
		if(v1.length != v2.length){
			return false;
		}
		
		for (int i = 0; i < v2.length; i++) {
			if(v1[i] != v2[i]){
				return false;
			}
		}
		
		return true;
	}

	@Override
	public String toString() {
		return value;
	}
}

四.switch使用字符串细节

两个字符串hash值有可能相同(利用反编译便于理解)

代码实现：

package com.dream.test02;

public class Test04 {

	public static void main(String[] args) {

		String str = "ab";

		switch (str) {//switch (str.hashCode()) {
		case "ab"://case 3104:
			if(str.equals("ab")){
				System.out.println("ab");
			}
			break;
		case "aa"://case 3105:
			if(str.equals("aa")){
				System.out.println("aa");
			}
			break;
		case "bC"://case 3105:
			if(str.equals("bC")){
				System.out.println("bb");
			}
			break;
		}

	}
}

五.final的使用

作用：

作用：
1.修饰变量 - 常量
存储在常量池中，直到项目结束才会被销毁
2.修饰类，类不能被继承
3.修饰方法，方法不能被重写

代码实现：

package com.dream.test03;

//A类不能有子类
//public final class A {
public class A {

	//该方法不能被子类重写
	public final void method(){}
}
package com.dream.test03;

public class B extends A{
	//当父类A被final修饰，B不能继承A
    //父类中被final修饰的方法不能在子类中重写
}

六.抽象类

抽象方法：

抽象方法：没有代码块并使用abstract修饰的方法，交给非抽象的子类去重写
应用场景：当一个方法必须在父类中出现，但是这个方法又不好实现，就把该方法变成抽象方法，或交给非抽象的子类去实现

需求：

//需求：编写人类、中国人、日本人
package com.study.test02;

public abstract class Person {
	private String name;
	private int age;
	private char sex;
	public Person() {
		super();
	}
	public Person(String name, int age, char sex) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	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 char getSex() {
		return sex;
	}
	public void setSex(char sex) {
		this.sex = sex;
	}
	
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", sex=" + sex + "]";
	}
	
	public abstract void eat();
}

package com.study.test02;

public class Japanese extends Person{

	private String yearNums;

	public Japanese() {
		
	}
	
	public String getYearNums() {
		return yearNums;
	}


	public void setYearNums(String yearNums) {
		this.yearNums = yearNums;
	}

	public Japanese(String name, int age, char sex, String yearNums) {
		super(name, age, sex);
		this.yearNums = yearNums;
	}


	@Override
	public String toString() {
		return "Japanese [yearNums=" + yearNums + ", toString()=" + super.toString() + "]";
	}

	@Override
	public void eat() {
		System.out.println(super.getName() + "吃生鱼片");
	}
	
}

package com.study.test02;

public abstract class Chinese extends Person{

	private String ID;
	
	public Chinese() {
		
	}
	
	public Chinese(String name, int age, char sex, String iD) {
		super(name, age, sex);
		ID = iD;
	}

	public String getID() {
		return ID;
	}

	public void setID(String iD) {
		ID = iD;
	}

	@Override
	public String toString() {
		return "Chinese [ID=" + ID + ", toString()=" + super.toString() + "]";
	}
	
	public abstract void hobby();
}

package com.study.test02;

public class SiChuan extends Chinese{

	public SiChuan() {
		super();
	}

	public SiChuan(String name, int age, char sex, String iD) {
		super(name, age, sex, iD);
	}

	@Override
	public void hobby() {
		System.out.println(super.getName() + "打麻将");
		
	}

	@Override
	public void eat() {
		System.out.println(super.getName() + "吃火锅");
	}

	@Override
	public String toString() {
		return "SiChuan [toString()=" + super.toString() + "]";
	}

}

package com.study.test02;

public class GuangDong extends Chinese{

	
	public GuangDong() {
		super();
	}

	public GuangDong(String name, int age, char sex, String iD) {
		super(name, age, sex, iD);
	}

	@Override
	public void hobby() {
		System.out.println(super.getName() + "做生意");
		
	}

	@Override
	public void eat() {
		System.out.println(super.getName() + "吃潮汕火锅");
	}

	@Override
	public String toString() {
		return "GuangDong [toString()=" + super.toString() + "]";
	}

}

package com.study.test02;

public class Test01 {
	public static void main(String[] args) {
		
		Japanese j = new Japanese("小峰由衣", 28 , '女', "令和");
		j.eat();
		System.out.println(j);
		
		SiChuan sc = new SiChuan("林成", 18 , '男', "123456789");
		sc.eat();
		System.out.println(sc);
		
		GuangDong gd = new GuangDong("李嘉诚", 80 , '男', "987654321");
		gd.eat();
		System.out.println(gd);
	}
}

/*输出结果：
小峰由衣吃生鱼片
Japanese [yearNums=令和, toString()=Person [name=小峰由衣, age=28, sex=女]]
林成吃火锅
SiChuan [toString()=Chinese [ID=123456789, toString()=Person [name=林成, age=18, sex=男]]]
李嘉诚吃潮汕火锅
GuangDong [toString()=Chinese [ID=987654321, toString()=Person [name=李嘉诚, age=80, sex=男]]]
*/

深入抽象类：

1.抽象类中只能有抽象方法？

抽象类里可以有构造方法、静态方法、成员方法

2.抽象类中不可以没有抽象方法？

可以没有抽象方法，但是这样毫无意义

3.如果父类是抽象类，则子类必须实现父类的抽象方法？

子类如果是抽象类，可以不实现父类对的抽象方法

4.抽象类不能有构造方法？

可以有构造方法的

5.可以使用new关键字来创建抽象类对象？

不可以的，创建出的是匿名内部类的对象

代码实现：

public static void main(String[] args) {

    //1.创建匿名类，继承Chinese，重写eat、hobby方法
    //2.创建匿名类的对象
    //3.赋值给父类的引用
    Chinese c = new Chinese() {
        @Override
        public void eat() {
        }
        @Override
        public void hobby() {
        }
    };
}

七.接口

含义：

1.接口是特殊的抽象类

2.接口中只能有静态常量和抽象方法

3.JDK1.8的新特性允许接口中使用默认方法和静态方法

作用：

制定规范

代码实现：

package com.dream.test06;

public class Test01 {
	
	public static void main(String[] args) {
		
		A a = new A();
		a.defaultMethod();
		
		I1.staticMethod();
		
	}
}
package com.dream.test06;

public interface I1 {

	//默认添加public static final
	int i = 100;
	
	//默认添加abstract
	public void method01();
	public void method02();
	
	//默认方法
	default void defaultMethod(){
		System.out.println("接口中的默认方法");
	}
	
	//静态方法
	public static void staticMethod(){
		System.out.println("接口中的静态方法");
	}
	
}
package com.dream.test06;

public class A implements I1{

	@Override
	public void method01() {
	}

	@Override
	public void method02() {
	}

}

八.深入接口

类——接口的关系：

类 - 类：单继承

类 - 接口：多实现

接口 - 接口：多继承

面试题：

1.一个类可以实现多个接口？可以
2.一个接口可以实现多个接口？不可以，接口与接口之间是多继承关系
3.接口里面的方法不一定都是抽象的？JDK1.8开始接口中允许默认方法和静态方法
4.接口解决了类的单继承问题？是的
5.一个类是否可以继承一个类并同时实现多个接口？可以
6.接口可以new对象？不可以，创建的是匿名内部类的对象

代码实现：

package com.dream.test07;

public interface I1 {
	
	public void i1Method01();

	public void method01();
	
	default void method02(){}
}
package com.dream.test07;

public interface I2 {
	
	public void i2Method01();
	
	public void method01();
	
	default void method02(){}

}
package com.dream.test07;

public interface I3 extends I4,I5{
	
	public void i3Method01();

}
package com.dream.test07;

public interface I4 {
	
	public void i4Method01();

}
package com.dream.test07;

public interface I5 {
	
	public void i5Method01();

}
package com.dream.test07;

public class A extends Object implements I1,I2,I3{

	@Override
	public void i2Method01() {
	}

	@Override
	public void i1Method01() {
	}

	@Override
	public void i4Method01() {
	}

	@Override
	public void i5Method01() {
	}

	@Override
	public void i3Method01() {
	}

	//I1、I2中都有method01的抽象方法，在实现类中只实现一个
	@Override
	public void method01() {
	}

	@Override
	public void method02() {
		//在实现类中调用I1接口中的默认方法
		//I1.super.method02();
		I2.super.method02();
	}

}
public class Test01 {
	
	public static void main(String[] args) {
        
		//1.创建匿名类，实现I5接口中的i5method01方法
		//2.创建匿名类的对象
		//3.赋值给接口的引用
		I5 i5 = new I5() {
			@Override
			public void i5Method01() {
			}
		};
	}
}

一、Connection接口

Connection接口代表与特定的数据库的连接，在连接上下文中执行SQL语句并返回结果，该类的常用方法如下：

Connection接口的常用方法

方法	功能描述
createStatement()	创建Statement对象
createStatement(int resultSetType,int resultSetConcurrency)	创建一个Statement对象，该对象将生成具有给定类型、并发性和可保存性的ResultSet对象
preparedStatement()	创建预处理对象preparedStatement
isReadOnly()	查看当前Connection对象的读取模式是否是只读形式
setReadOnly()	设置当前Connection对象的读写模式，默认是非只读模式
commit()	使所有上一次提交/回滚后进行的更改成为持久更改，并释放此Connection对象当前持有的所有数据库锁
roolback()	取消在当前事务中进行的所有更改，并释放此Connection对象当前持有的所有数据库锁
close()	立即释放此Connection对象的数据库和JDBC资源，而不是等待它们被自动释放

 

二、Statement接口

Statement接口用于在已经建立的基础上向数据库发送SQL语句。在JDBC中有3种Statement对象，分别是Statement、PreparedStatement和CallableStatement。Statement对象用于执行不戴参数的简单SQL语句；PreparedStatement继承了Statement，用来执行对数据库的存储过程的调用。Statement接口的常用方法如下：

Statement接口种常用的方法

方法	功能描述
execute(String sql)	执行静态的SELECT语句，该语句可能返回多个结果集
executeQuery(String sql)	执行给定的SQL语句，该语句返回单个ResultSet对象
clearBatch()	清空此Statement对象的当前SQL命令列表
executeBatch()	将一批命令提交给数据库来执行，如果全部命令执行成功，则返回更新计数组成的数组。数组元素的排序与SQL语句的添加顺序对应
addBatch()	将给定的SQL命令添加到此Statement对象的当前命令列表中。如果驱动程序不支持批量处理，将抛出异常
close()	释放Statement实例占用的数据库和JDBC资源

 

三、PreparedStatement接口

PreparedStatement接口用来动态地执行SQL语句。通过PreparedStatement实例执行的动态SQL语句，将被预编译并保存到PreparedStatement实例中，从而可以反复地执行该SQL语句，该接口的常用方法如下：

PreparedStatement接口提供的常用方法

方法	功能描述
setInt(int index,int k)	将指定位置的参数设置为int值
setFloat(int index,float k)	将指定位置的参数设置为float值
setLong(int index,long k)	将指定位置的参数设置为long值
setDouble(int index,double k)	将指定位置的参数设置为double值
setBoolean(int index,boolean k)	将指定位置的参数设置为boolean值
setDate(int index,date date)	将指定位置的参数设置为对应的date值
executeQuery()	在此PreparedStatement对象中执行SQL查询，并返回该查询生成的ResultSet对象
setString(int index,String s)	将指定位置的参数设置为对应的String值
setNull(int index,intsqlType)	将指定位置的参数设置为SQL NULL
executeUpdate()	执行前面包含的参数的动态INSERT、UPDATE或DELETE语句
clearParameters()	清除当前所有参数的值

 

四、DriverManager类

DriverManager类用来管理数据库中的所有驱动程序。它是JDBC的管理层，作用于用户和驱动程序之间，跟踪可用的驱动程序，并在数据库的驱动程序之间建立连接。如果通过getConnection()方法可以建立连接，则经连接返回，否则抛出SQLException异常，该类的常用方法如下：

DriverManager类的常用方法

方法	功能描述
getConnection(String url,String user,String passward)	指定三个入口参数(数据库的URL、用户名、密码)来获取与数据库的连接
setLoginTimeout()	获取驱动程序试图登录到某一数据库时可以等待的最长时间，单位为秒
println(String message)	将一条消息打印到当前的JDBC日志流中

 

 

 

 

 

 

五、ResultSet接口

ResultSet接口类似于一个临时表，用来暂时存放数据库查询操作所获得的结果集。ResultSet实例具有指向当前数据行的指针，指针开始的位置在第一条记录的前面，通过next()方法可以将指针向下移动。该接口的常用方法如下：
 

ResultSet接口提供的常用方法

方法	功能描述
getInt()	以int形式获取此ResultSet对象的当前行的指定列值。如果列值是NULL，则返回值是0
getFloat()	以float形式获取此ResultSet对象的当前行的指定列值。如果列值是NULL，则返回值是0
getDate()	以data形式获取此ResultSet对象的当前行的指定列值。如果列值是NULL，则返回值是null
getBoolean()	以boolean形式获取此ResultSet对象的当前行的指定列值。如果列值是NULL，则返回值是null
getString()	以String形式获取此ResultSet对象的当前行的指定列值。如果列值是NULL，则返回值是null
getObject()	以Object形式获取此ResultSet对象的当前行的指定列值。如果列值是NULL，则返回值是null
first()	将指针移到当前记录的第一行
last()	将指针移到当前记录的最后一行
next()	将指针向下移一行
beforeFirst()	将指针移到集合的开头
afterLast()	将指针移到集合的尾部
absolute(int index)	将指针移到ResultSet给定编号的行
isFrist()	判断指针是否位于当前ResultSet集合的第一行。如果是返回true，否则返回false
isLast()	判断指针是否位于当前ResultSet集合的最后一行。如果是返回true，否则返回false
updateInt()	用int值更新指定列
updateFloat()	用float值更新指定列
updateLong()	用指定的long值更新指定列
updateString()	用指定的string值更新指定列
updateObject()	用Object值更新指定列
updateNull()	将指定的列值修改为NULL
updateDate()	用指定的date值更新指定列
updateDouble()	用指定的double值更新指定列
getrow()	查看当前行的索引号
insertRow()	将插入行的内容插入到数据库
updateRow()	将当前行的内容同步到数据表
deleteRow()	删除当前行，但不同步到数据库中，而是在执行close()方法后同步到数据库

 

目录

什么是抽象类

抽象类再实现多态中的意义 

接口是什么

---

 各位铁汁们大家好呀😊！

😎今天让我们继续学习java，看看java中的抽象类和接口到底是什么🤔？ 

什么是抽象类

🍑我们之前学过什么是类，那么抽象类是不是也是类的一种呢？

听名字就感觉好抽象呀！说对了，他就是抽象的，不是具体的。在类中没有包含足够的信息来描绘一个具体的对象，这样的类称为抽象类。

🌰来看一个抽象类的例子

// 抽象类和抽象方法需要被 abstract 关键字修饰
abstract class Shape {
    // 抽象类中的方法一般要求都是抽象方法，抽象方法没有方法体
    abstract void draw();
}

大家觉得这个抽象类是不是什么也没干，他唯一的方法draw()还是空的。

像这样的类是不是就没有包含足够的信息来描绘一个具体的对象，自然也就不能实例化对象了。不信你看：

🍑那既然一个类不能实例化，那这种抽象类存在的意义是什么呀🤔？别急，存在即合理，听我慢慢道来。

---

抽象类在实现多态中的意义 

🍑抽象类存在的一个最大意义就是被继承，当被继承后就可以利用抽象类实现多态。

来看一段代码

// 抽象类和抽象方法需要被 abstract 关键字修饰
abstract class Shape {
    // 抽象类中的方法一般要求都是抽象方法，抽象方法没有方法体
    abstract void draw();
}
// 当一个普通类继承一个抽象类后，这个普通类必须重写抽象类中的方法
class Cycle extends Shape {
    @Override
    void draw() {  // 重写抽象类中的draw方法
        System.out.println("画一个圆圈");
    }
}

public class Test4 {
    public static void main(String[] args) {
        //Shape shape = new Shape();  抽象类虽然不能直接实例化
        // 但可以把一个普通类对象传给一个抽象类的引用呀，即父类引用指向子类对象
        Shape shape = new Cycle(); // 这称作：向上转型
        
        /*Cycle cycle = new Cycle();
          Shape shape = cycle // 这是向上转型的另一种写法
         */
        shape.draw();         // 通过父类引用调用被子类重写的方法
    }
}

运行之后你就会发现神奇的一幕：

 

大家在看完了代码可能会有很多疑问，别急咱们一个一个的说，

📝什么是向上转型：一句话总结就是“父类引用指向子类对象”

向上转型后的变化

1. 🏀关于方法：父类引用可以调用子类和父类公用的方法（如果子类重写了父类的方法，则调用子类的方法），但子类特有的方法无法调用。
2. 🏀关于属性: 父类引用可以调用父类的属性，不可以调用子类的属性

向上转型的作用

1. 🐟减少一些重复性的代码
2. 🐟对象实例化的时候可以根据不同需求实例化不同的对象

🌰这样的话就我们上面的代码就可以理解了

​ 

📝看来，我们可以通过子类对抽象类的继承和重写，抽象类还真有点用呀！

🍑但这和多态有什么关系呢，抽象类用起来这么麻烦，我还不如直接用普通类，也能达到这样的效果，还不用再写一个子类呢😫？

🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟

🌰那行，你再看看下面的代码，你就知道抽象类在实现多态时的好处了。 

abstract class Shape {
    public abstract void draw(); // 抽象方法不能里有具体的语句
}
// 当一个普通类继承一个抽象类的时候，再这个子类中必须重写抽象类中的抽象方法
class Cycle extends Shape {  
    @Override              // 如果不重写会报错，但如果继承的是普通类则不会报错，用抽象类更安全
    public void draw() {
        System.out.println("画一个圆圈");
    }
}
class Flower extends Shape { // 不同的子类对父类的draw方法进行了不同的重写
    @Override
    public void draw() {
        System.out.println("画一朵花");
    }
}
class Square extends Shape {
    @Override
    public void draw() {
        System.out.println("画一个正方形");
    }
}

public class Test4 {
    public static void main(String[] args) {
        Cycle cycle = new Cycle();   // 子类引用cycle
        Flower flower = new Flower(); // 子类引用flower
        Square square = new Square();
        
        // 数组的类型是Shape,即数组中每一个元素都是一个父类引用
        // 在这个过程其实也发生了向上转型，对抽象类中的方法进行了重写
        Shape[] shapes = {cycle, flower, square};  // 父类引用引用不同的子类对象
        for (int i = 0; i < shapes.length; i++) {
            Shape shape = shapes[i]; // 父类引用shape指向—>当前所对应的子类对象

            shape.draw();  // 通过父类引用调用子类重写的draw方法
        }

    }
}

🍑调用同一个方法竟然打印出了不同的结果😮，这难道就是所谓的多态🤔 

 是不是有点懵😂，下面我们来解释一下😉

// 对上面的代码补充一下
// 可能你对 Shape[] shapes = {cycle, flower, square};不太理解
// 但上面的代码就相当于 

 Shape[] shapes1 = new Shape[3]; // 有三个不同的子类对象呀！数组大小为3

// (将指向->子类对象)的子类引用赋值给父类对象，不就相当于该夫类引用指向->所对应的子类对象吗
//这是向上转型的另一种写法，应为前面已经实例化了子类对象  Cycle cycle = new Cycle();   
 shapes1[0] = cycle;  // 如果前面没实例化子类对象，就要写成shape1[0] = new Cycle
 shapes1[1] = flower;
 shapes1[2] = square;

对于多态来说，他有这三个要素

1. 继承（我们刚才的Cycle类继承Shape抽象类）
2. 重写（我们子类对draw方法的重写）
3. 父类指向子类对象（就是shape1[0] = cycle -->也可以称作向上转型) 

🍑回头再看一下我们的代码，是不是就刚好符合了多态的三要素😉。

📝当我们的父类引用指向不同的子类对象时，当我们调用同一个draw方法时却输出了不同的结果。（其实就是该方法再子类中被重写成了不同形式）这就叫做多态 。

嘻嘻😂，其实只要只要结合着例子来看，多态也没那么难理解呀😎

  

🍑那为啥一定要用抽象类呢😂？我一个普通类继承普通类来实现多态不可以吗🤔

🌰当然可以，但不太安全有风险；

     

但如果是抽象类的话，就不一样了😉 

  

🍑从这我们也可以看出，当用抽象类的时候，编译器自动就对我们是否重写进行了校验，而充分利用编译器的校验, 在实际开发中是非常有意义的 。所以说抽象类还是有用的，嘻嘻😉

📝好了，相信到这里你对抽象类也有了一个大概的认识😊，下面我们来简单做一下总结

1. 使用abstract修饰的类或方法，就抽象类或者抽象方法
2. 抽象类是不能具体的描述一个对象，不能用抽象类直接实例化对象
3. 抽象类里面的成员变量和成员方法，都是和普通类一样的，只不过就是不能进行实例化了
4. 当一个普通类继承这个抽象类后，那么这个普通类必须重写抽象类当中的所有的抽象方法🤔（我们之前说过抽象类是不具体的，没有包含足够的信息来描述一个对象，所以我们需要把他补充完整）

   ---

5. 但当一个抽象类A继承了抽象类B，这是抽象类A就可以不重写抽象类B当中的抽象方法
6. final不能修饰抽象类和抽象方法（因为抽象类存在的最大意义就是被继承，而被final修饰的不能被继承，final和抽象，他们两个是天敌😂）
7. 抽象方法不能被private修饰（抽象方法一般都是要被重写的，你被private修饰了，还怎么重写😫）
8. 抽象类当中不一定有抽象方法，但如果一个类中有抽象方法，那么这个类一定是抽象类。

🌰哈哈，上面的8条总结是不是臭长臭长的，大家也不用专门去记（用的多了，自然就记住了😉）

🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟

---

接口是什么

🍑抽象类是从多个类中抽象出来的模板，如果将这种抽象进行的更彻底，则可以提炼出一种更加特殊的“抽象类”——接口（Interface）🤔。

📝接口是Java中最重要的概念之一，它可以被理解为一种特殊的类，不同的是接口的成员没有执行体，是由全局常量和公共的抽象方法所组成😎。

如何定义一个接口呢？下面我们来看一个栗子🌰

//接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口

public interface 接口名称{
// 定义变量
int a = 10;      // 接口当中的成员变量默认都是public static final

// 抽象方法
public abstract void method1(); // public abstract 是固定搭配，可以不写
void method2();  //  接口当中的成员方法默认都是public abstract, 更推荐用第二种来定义方法 
}

可以看到接口和类其实还是有很多相似点：

📝接口中也包含抽象方法，所以也不能直接实例化接口🤔，那么我们怎么用接口呢？

🍑哈哈，很简单😉，我们再用一个普通类实现这个接口不就行了吗😂，不同的是抽象类是被子类来继承而实现的，而接口与类之间则是用关键字implements来实现。

📝就像普通类实现实现抽象类一样，一个类实现某个接口则必须实现该接口中的抽象方法，否则该类必须被定义为抽象类🤔。

---

 通过接口实现多态

🍑铁汁们！刚才我们是用抽象类来实现多态，那么现在我们可以尝试用接口来实现多态，嘻嘻😎

接口可以看成是一种特殊的类，只能用 interface 关键字修饰
interface IShape {
    int a = 10;   接口当中的成员变量默认都是public static final
    int b = 23;
    void draw();  接口当中的成员方法一般只能是抽象方法，默认是public abstract（JDK1.8以前）
  
    default void show() {
        System.out.println("接口中的其他方法");//接口中的其他方法也可以实现，但要用default修饰
    }
    public static void test() {
        System.out.println("这是接口当中的一个静态的方法");
    }
}

// 一个普通的类要想实现接口，可以用implement, 
//因为接口也是抽象方法的，所以实现接口的这个类也要重写抽象方法
class Cycle implements IShape {

    @Override
    public void draw() {
        System.out.println("画一个圆圈");
    }
}
class Square implements IShape {
    @Override
    public void draw() {
        System.out.println("画一个正方形");
    }
}
class Flower implements IShape {

    @Override
    public void draw() {
        System.out.println("画一朵花");
    }
}
public class Test4 {
    public static void main(String[] args) {
        // IShape iShape = new IShape(); 接口也不能直接实例化
        Cycle cycle = new Cycle();
        Square square = new Square();
        Flower flower = new Flower();
        // 这里的IShape接口就相当与抽象类中父类，接口类型也是一种引用类型

        IShape[] iShapes = {cycle, square, flower}; // 这个过程其实就发生了向上转型

        for (IShape iShape : iShapes) { // 增强型的for—each循环，也可以写成普通的for循环形式
            iShape.draw();              // 通过重写实现了多态
        }
    }
}
引用变量cycle和square都赋值给了Shape类型的引用变量shape,
但当执行shape.draw()时，java虚拟机到底要调用谁重写的的draw方法，
就看此时接口引用的是那个对象的，是shape的、还是cycle的

 😎看一下运行结果😎

 看完代码你可能有点晕😫，但没关系。一般接口咱也不这么用，直接使用抽象类不就好了😉（我只是演示一下用接口也能实现多态😂）

🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑

📝下面我们来总结一下Java中接口的几个主要特点

1. 🌰接口中可以包含变量和方法，变量被隐式指定为 public static final，方法被隐式指定为 public abstract（JDK 1.8 d一个类可以同时实现多个接口，一个类实现某个接口则必须实现该接口中的抽象方法，否则该类必须被定义为抽象类
2. 🌰接口支持多继承，即一个接口可以继承（extends）多个接口，间接解决了 Java 中类不能多继承的问题。

🍑那么接口一般用在什么地方呢？

• 一般情况下，实现类和它的抽象类之前具有 "is-a" 的关系，但是如果我们想达到同样的目的，但是又不存在这种关系时，使用接口。
• 由于 Java 中单继承的特性，导致一个类只能继承一个类，但是可以实现一个或多个接口，此时可以使用接口。

🌰下面就让我们来看看接口的正确用法：帮助java实现“ 多继承 ”😎

由于 Java 中单继承的特性，导致一个类只能继承一个类，但是可以实现一个或多个接口，此时可以使用接口。
class Animal {
    String name;        // 不能使用private,后面的子类也要用

    public Animal(String name) { // 父类的自定义的构造方法
        this.name = name;
    }
}
interface IFlying {   // 自定义多种接口
    void fly();
}
interface IRunning {
    void run();
}
interface ISwimming {
    void swimming();
}
// 小鸭子，不仅会跑，还会游泳、飞行
一个类继承父类，并实现多个接口，间接的解决java中不能多继承的问题
class Duck extends Animal implements IRunning, ISwimming, IFlying {

    public Duck(String name) {  // 子类构造方法
        super(name);            // 必须在子类构造方法的第一行
        // 在给实现子类的构造方法前，先要用super()调用实现父类的构造方法，比较先有父后有子呀！
        // 因为父类自己定义了构造方法，编译器不会自动给给子类构造方法中添加super();来实现父类的构造方法，需要我们自己实现
    }
    // 对接口中的抽象方法进行重写
    @Override
    public void fly() {
        System.out.println(this.name + "正在用翅膀飞");
    }

    @Override
    public void run() {
        System.out.println(this.name + "正在用两条腿跑");
    }

    @Override
    public void swimming() {
        System.out.println(this.name + "正在漂在水上");
    }

}

public class 接口的使用 {  // 不用学我用中文名作为类名，我只是为演示方便
    public static void main(String[] args) {
        Duck duck = new Duck("第一个小鸭子");  // 实例化鸭子对象
        duck.fly();  // 通过引用 变量名.方法名 输出重写后的方法
        duck.run();
        duck.swimming();
    }
}
有人可能会说干嘛用接口，我直接在父类Animal中实现fly、run、swimming这些属性，
然后不同的动物子类再继承父类这些方法不行吗？

但问题是，鸭子会fly、swimming，那猫会飞和游泳吗？你再写个其他动物的子类是不是就不行了
而用接口呢？我们只是把这种飞、游泳的行为给抽象出来了，

只要一个子类有这种行为，他就可以实现相对应的接口，接口是更加灵活的

 📝上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多个接口。

 📝继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性 ，能实现接口的类和该接口并不一定有is_a的关系，只要该类有这个接口的特性就行

猫是一种动物, 具有会跑的特性.

青蛙也是一种动物, 既能跑, 也能游泳

鸭子也是一种动物, 既能跑, 也能游, 还能飞

 🍑这样设计有什么好处呢? 时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型，只要这个类有有这个特性就好。

举个栗子🌰

class Robot implements IRunning {
    private String name;
    public Robot(String name) {
        this.name = name;
    }
    // 对run方法进行重写
    @Override
    public void run() {
        System.out.println("机器人" + this.name + "正在跑");
    }
}
public class Test4 {
    public static void main(String[] args) {
        Robot robot1 = new Robot("图图");
        robot1.run();
    }
}
// 执行结果
机器人图图正在跑

😎只要能跑就行，管他是机器人还是动物呢😂，接口是不是很灵活呀！

同时在实际的开发过程中，一般来说，一个类是一个Java文件，一个接口也是一个Java文件。大家也要在平时就养成这个好习惯呀！

哈哈，不知道现在你对抽象类和接口的认识是不是又上升了一个高度呢？嘻嘻，我们下篇博客再见了，下篇让我们瞅瞅Java中常用的接口有哪些😉

 每天进步一点点，铁汁们，一起加油😎😎😎