java——多态，向上转型，向下转型，抽象类抽象方法，工厂模式，接口与各种类的区别，内部类，静态内部类

1.多态

1）向上转型

向上转型是隐式转换，向上转型后不能调用子类方法；

2）向下转型

向下转型必须是强制类型转换，能调用子类方法

多态的使用

1）向上向下转型

2）父类做形参

3）父类做返回类型

多态总结

2.抽象类、抽象方法（abstract）

规则：

含有抽象方法就是抽象类
abstract 修饰类：
类中的方法可以不全实现，部分普通函数；也可以全实现（普通类一样）；也可以全不实现，只有方法声明；
子类必须重写抽象类的抽象方法；
abstract 修饰方法：
方法不能被实现，没有方法体

抽象类中不能有 final static 修饰方法

3.接口

接口（interface）是最彻底的抽象。

接口中都是未实现的方法。

接口一个极端的抽象类，当抽象类的所有方法都是抽象方法时，该抽象类的作用与接口等价。

接口中不能有任何实现；可以有初始化后的变量和静态变量和常量；所有变量默认为final，static，public类型；final，static，public变量;
所有方法默认加public abstract；
static 方法可以执行；

一个类只能继承 extends 自一个父类，但可以实现 implements多个接口。

Class 普通类 （全实现）
Abstract class (部分实现，也可全实现，也可全不实现)
Interface (完全未实现)

抽象类与接口的区别和相同：都不能实例化，都有常量和抽象方法；

抽象类：其方法可是非抽象也可是抽象方法，其被继承；可以有变量；当子类没有重写所有抽象方法时，子类也成为抽象类；

接口：所有方法都是抽象方法，其被实现；接口中变量不能初始化实现，只能有常量；

接口中 变量默认是public final static 型

接口中 方法默认是 public abstract 型

pubic void a();
未实现方法必须在抽象类或接口中出现 并abstract修饰；

4.内部类，静态内部类

内部类

public class Outer {
	private int x ;
	public Inner getInner() {
		return new Inner();
	}
	public class Inner {
		public void print(String str) {
			x++;
			System.out.println(str + "；" );
		} 
	}
	public static void main(String[] args) {
		//初始化方式一
		Outer outer = new Outer();
		Outer.Inner inner1 = outer.new Inner();
		inner1.print("我是内部类成员方法");
		//初始化方式二，调用
		Outer.Inner inner2 = outer.getInner();
		inner2.print("我是内部类成员方法");
		}
 }

静态内部类

public class Outer {
	private int x;
	static class Inner{
		public static void main(String[] args) {
			Outer outer = new Outer();
			System.out.println(outer.x);
			}
		 }
  }

5.工厂模式

简单工厂、工厂模式、抽象工厂

工厂模式：
1、简单工厂（编写）（只有一个工厂） 只负责加工一种产品类
2、工厂模式（有N个工厂） 有N个工厂，负责加工N种产品
3、抽象工厂（有N个工厂） 抽象工厂下面实现了N个工厂，负责加工N种产品。
·

简单工厂

一种创建对象的方法，但它让子类来决定创建那种类型的对象。*****************************

一种创建对象的方法，在使用该类时，由需求决定具体实例化那个类。*****************************

接口：IDBUtil
子类：MysqlUtil,OracleUtil
测试运行类：App
工厂类：Factory
配置文件：db.properties

//接口
public interface IDBUtil {
    void execute(String sql);
    ResultSet query(String sql);//ResultSet，数据库结果集的数据表，通常通过执行查询数据库的语句生成。
}

//子类
public class MysqlUtil implements IDBUtil{
    @Override
    public void execute(String sql) {
        System.out.println("Mysql:"+sql);
    }

    @Override
    public ResultSet query(String sql) {
        return null;
    }
}

//=============================================
public class OracleUtil implements IDBUtil {
    @Override
    public void execute(String sql) {
        System.out.println("Oracle:"+sql);
    }

    @Override
    public ResultSet query(String sql) {
        return null;
    }
}

//Factory
public class Factory {

    public static IDBUtil getIDBUtil() throws FileNotFoundException,IOException {		//返回子类的构造方法 new
        Properties properties=new Properties(); 		//Properties（Java.util.Properties），该类主要用于读取Java的配置文件
        File file=new File("src/db.properties"); 		//Java 流(Stream),Java文件类以抽象的方式代表文件名和目录路径名。
        InputStream inputStream=new FileInputStream(file);		//InputStream 所有字节输入流的 超类

        properties.load(inputStream);		//加载配置文件内容

        String value=properties.getProperty("TYPE");	//获得变量的值
        String type = value;
        switch (type){
            case "Mysql":
                return new MysqlUtil();
            case "Sqlserver":
                return new SqlserverUtil();
            case "Oracle":
                return new OracleUtil();
            default:
                break;
        }
        return null;
    }
}

//db.properties  配置文件

TYPE=Mysql

//测试运行类 App

public class App {
    public static void main(String[] args) throws IOException {
        IDBUtil idbUtil=null;
        
        idbUtil=Factory.getIDBUtil();	//获得子类类型的new实例化，向上转型

        idbUtil.execute("insert");

    }
}