java日常记录5 –面向对象之封装，继承，多态

面向对象

刚刚开始接触编程的时候，我们最常听到的是面向过程编程，面向对象编程。这里面向过程编程我就不在描述，主要描述面向对象也就是 Object-Oriented Programming, 简称OOP。
自然界的万事万物都可以称作对象，以鸟为例子，鸟有羽毛，有爪子，有翅膀。。。等等，这些都可以成为对象的属性。那么我们具体而言，面向对象的本质是什么？

面向对象编程的本质就是：以类的方式组织代码，以对象的组织(封装)数据。

这里概括一下面向对象的三大主要特性：

封装(Encapsulation)

封装是面向对象的特征之一，是对象和类概念的主要特性。封装是把过程和数据包围起来，对数据的访 问只能通过指定的方式。
在定义一个对象的特性的时候，有必要决定这些特性的可见性，即哪些特性对外部是可见的，哪些特性 用于表示内部状态。
封装保证了模块具有较好的独立性，使得程序维护修改较为容易。对应用程序的修改仅限于类的内部， 因而可以将应用程序修改带来的影响减少到最低限度。

//使用JDBC的连接为对象，我们来分析封装的好处
public class DBHelper {
	//加载成功，在整个程序中，只需要加载在一起的好了
    //放到静态快里边：因为静态快，自动执行，并且只执行一次
	static {
		try {
			Class.forName(MyProperties.getInstance().getProperty("driverClass"));
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}//静态方法，可以不实例化，而直接调用
		
	}

	//获取连接这一段代码，太长了，对此我们封装一下
	public Connection getCon() {
		Connection conn = null;
		//在这里，连接地址，用户名，和密码，对于不同的用户，可能不一样
		//我们可以将这个三个东西，作为配置项，配置到程序中
		try {
			conn = DriverManager.getConnection(MyProperties.getInstance().getProperty("url"),
					MyProperties.getInstance());
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return conn;
	}
	/**
	 * 增删改
	 * @param sql 要执行的语句
	 * @param params 要注入的参数
	 * @return
	 */
	public int doUpdate(String sql,List<Object> params) {
		//定义返回值
		int result = -1;
		try {
			//获取连接
			Connection conn = getCon();
			//创建预处理语句对象
			PreparedStatement ps = conn.prepareStatement(sql);
			
			//如果有问号，有参数，要注入参数
			doParams(ps,params);
			//执行
			
				result = ps.executeUpdate();

			//关闭各种连接，接口
			closeAll(conn,null,ps);
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return result;
		
	}
	
	/**
	 * 查询语句
	 * @param sql
	 * @param params
	 * @return
	 */
	public List<Map<String,Object>> findAll(String sql,List<Object>params){
		List<Map<String,Object>> list = new ArrayList<Map<String,Object>>();
		try {
			//获取连接
			Connection conn = getCon();
			//创建预处理语句对象
			PreparedStatement ps = conn.prepareStatement(sql);
			//如果有问号，有参数，要注入参数
			doParams(ps, params);
			
			//执行这里开始不一样
			ResultSet rs = ps.executeQuery();
			//我们要将resultSet里边的值，转化为List<Map<String,Object>>
			//Map<String,Object> 键值对     键  ： 表的字段  值:这个字段对应的值
			ResultSetMetaData rsmd =rs.getMetaData();
			//我们将所有的列名，存到一个数组中
			String [] cnames = new String [rsmd.getColumnCount()];
			for(int i =0 ;i<cnames.length;i++) {
				cnames[i] = rsmd.getColumnName(i+1);
			}
			//开始获得数据
			while (rs.next()) {
				//创建map对象
				Map<String,Object> map = new HashMap<String, Object>();
				for(int i =0;i<cnames.length;i++) {
					// 键          转为小写    值
					map.put(cnames[i].toLowerCase(),rs.getObject(cnames[i]));
				}
				//将map添加到list中
				list.add(map);
			}
			//关闭
			closeAll(conn,rs,ps);
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return list;
	}
	
	public List<Map<String,Object>> findAll(String sql,Object...params){
		List<Map<String,Object>> list = new ArrayList<Map<String,Object>>();
		try {
			//获取连接
			Connection conn = getCon();
			//创建预处理语句对象
			PreparedStatement ps = conn.prepareStatement(sql);
			//如果有问号，有参数，要注入参数
			doParams(ps, params);
			
			//执行这里开始不一样
			ResultSet rs = ps.executeQuery();
			//我们要将resultSet里边的值，转化为List<Map<String,Object>>
			//Map<String,Object> 键值对     键  ： 表的字段  值:这个字段对应的值
			ResultSetMetaData rsmd =rs.getMetaData();
			//我们将所有的列名，存到一个数组中
			String [] cnames = new String [rsmd.getColumnCount()];
			for(int i =0 ;i<cnames.length;i++) {
				cnames[i] = rsmd.getColumnName(i+1);
			}
			//开始获得数据
			while (rs.next()) {
				//创建map对象
				Map<String,Object> map = new HashMap<String, Object>();
				for(int i =0;i<cnames.length;i++) {
					// 键转为小写值
					map.put(cnames[i].toLowerCase(),rs.getObject(cnames[i]));
				}
				//将map添加到list中
				list.add(map);
			}
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return list;
		
		
		}
	
	
	
	//注入参数
	private void doParams(PreparedStatement ps, List<Object> params) {
		if(ps != null &&params!= null&& params.size()>0) {
			//循环注入
			for(int i = 0;i<params.size();i++) {
				try {
					ps.setObject(i+1, params.get(i));
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
	}
	
	//重载                                                                                                                      ...量词参数  代表任意个参数 本质是数组
	private void doParams(PreparedStatement ps, Object...params) {
		if(ps != null && params.length>0) {
			//循环注入
			for(int i = 0;i<params.length;i++) {
				try {
					ps.setObject(i+1, params[i]);
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
	}
	
	
	
	public int doUpdate(String sql,Object... params) {
		//定义返回值
		int result = -1;
		try {
		//获取连接
		Connection conn = getCon();
		//创建预处理语句对象
			PreparedStatement ps = conn.prepareStatement(sql);
			//如果有问号，有参数，要注入参数
			doParams(ps,params);
			//执行
			result = ps.executeUpdate();
			//关闭各种连接，接口
			closeAll(conn,null,ps);
		} catch (SQLException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		//最终返回数据
		return result;
		
    }
	
	
      private void closeAll(Connection conn, ResultSet rs, PreparedStatement ps) {
    	  if(conn != null ) {
    		  try {
				conn.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
    	  }
    	  if(rs!= null ) {
    		  try {
				rs.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
    	  }
    	  if(ps != null ) {
    		  try {
				ps.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
    	  }
    	 }
}

public class MyProperties extends Properties {
	private static MyProperties myProperties;
	
	//构造函数私有化，这样做，是有一层特殊含义的：单例模式
	//单例，就是指只有一个实例
	private  MyProperties() {
		InputStream is = MyProperties.class.getClassLoader().getResourceAsStream("db.properties");
		//子类继承父类，就可以使用父类非私有的属性和方法
		try {
			this.load(is);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	//单例模式设计后，一定要有一个共有的方法，去让其他对象访问到这个属性
	public static MyProperties getInstance() {
		if(myProperties == null) {
			myProperties = new MyProperties();
		}
		return myProperties;
	}
}

#db.properties  oracle数据库
driverClass=oracle.jdbc.OracleDriver
url=jdbc:oracle:thin:@127.0.0.1:1521:orcl
user=scott
password=a

#mysql数据库
#driverClass=com.mysql.jdbc.Driver
#url=jdbc:mysql://127.0.0.1:3306/res
#user=root
#password=a

** 封装的作用和意义**

1.提高程序的安全性，保护数据。
2.隐藏代码的实现细节
3.统一用户的调用接口
4.提高系统的可维护性
5.便于调用者调用。

顺带这块将一下方法重载
类中有多个方法,有着相同的方法名,但是方法的参数各不相同,这种情况被称为方法的重载。方法的重载 可以提供方法调用的灵活性。

方法重载必须满足以下条件
1.方法名必须相同
2.参数列表必须不同(参数的类型、个数、顺序的不同)
3.方法的返回值可以不同，也可以相同。

public void test(Strig str){}
public void	test(int a){}
	
public void	test(Strig str,double d){}
public void	test(Strig str){}

public void	test(Strig str,double d){}
public void	test(double d,Strig str){}

继承(inheritance)

继承是一种联结类的层次模型，并且允许和支持类的重用，它提供了一种明确表述共性的方法。
新类继承了原始类后,新类就继承了原始类的特性，新类称为原始类的派生类(子类)，而原始类称为新类的基类(父类)。
派生类(子类)可以从它的基类(父类)那里继承方法和实例变量，并且派生类(子类)中可以修改或增 加新的方法使之更适合特殊的需要继承性很好的解决了软件的可重用性问题。

1.继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。

2.继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来 表示。

public class student extends Person{
}

3.子类和父类之间,从意义上讲应该具有”is a”的关系.

student is a person
dog is a animal

4.类和类之间的继承是单继承

一个子类只能”直接”继承一个父类,就像是一个人只能有一个亲生父亲
一个父类可以被多子类继承,就像一个父亲可以有多个孩子
注意：java类是单继承的（接口支持多继承）
注:java中接口和接口之间,也可以继承,并且是多继承。

5.父类中的属性和方法可以被子类继承

子类中继承了父类中的属性和方法后,在子类中能不能直接使用这些属性和方法,是和这些属性和方法原有 的修饰符(public protected default private)相关的。
例如 :
父类中的属性和方法使用public修饰,在子类中继承后”可以直接”使用
父类中的属性和方法使用private修饰,在子类中继承后”不可以直接”使用

public class Person{
	public void run(){}
	protected Object test()throws Exception{ 
		return null;
		}
	}
	//编译通过,子类继承父类,重写了run和test方法.
public class Student extends Person{
	public void run(){}

	public String test(){
		return "";
	}
}

Object类
java中的每一个类都是”直接” 或者 “间接”的继承了Object类.所以每一个对象都和Object类有”is a”的关系。从API文档中,可以看到任何一个类最上层的父类都是Object。(Object类本身除外)AnyClass is a Object。

System.out.println(任何对象 instanceof Object);
//输出结果:true
//注:任何对象也包含数组对象

//例如:
//编译后,Person类会默认继承Object
public class Person{}

//Student是间接的继承了Object
public class Student extends Person{}

Super关键字
子类继承父类之后,在子类中可以使用this来表示访问或调用子类中的属性或方法,使用super就表示访问或调用父类中的属性和方法。

1. super的使用
   【访问父类中的属性】

public class Person{
	protected String name = "zs";
	}
public class Student extends Person{ private 	
	String name = "lisi"; public void tes(String name)t{
	System.out.println(name); 	
	System.out.println(this.name); 
	System.out.println(super.name);
}

【调用父类中的方法】

public class Person{ public void print(){
	System.out.println("Person");
	}
}
public class Student extends Person{ 
	public void print(){
	System.out.println("Student");
}
public void test(){ 
	print();
	this.print();
	super.print();
	}
public class Person{
	}
public class Student extends Person{
	//编译通过,子类构造器中会隐式的调用父类的无参构造器
	//super();
	public Student(){
	}
}	

父类没有无参构造

public class Person{
	protected String name;
	public Person(String name){
		this.name = name;
	}
}
public class Student extends Person{
	//编译报错,子类构造器中会隐式的调用父类的无参构造器,但是父类中没有无参构造器
	//super();
public Student(){
	}
}

【显式的调用父类的有参构造器】

public class Person{ protected String name;
	public Person(String name){
		 this.name = name;
	}
}
public class Student extends Person{
//编译通过,子类构造器中显式的调用父类的有参构造器
	public 	Student(){
		super("tom");
	}
}

不管是显式还是隐式的父类的构造器,super语句一定要出现在子类构造器中第一行代码。所以this和
super不可能同时使用它们调用构造器的功能,因为它们都要出现在第一行代码位置。

public class Person{ 
	protected String name;
public Person(String name){ 
	this.name = name;
	}
}
public class Student extends Person{
//编译报错,super调用构造器的语句不是第一行代码
	public Student(){
	System.out.println("Student"); 
	super("tom");
	}
}

【super使用的注意的地方】
1.用super调用父类构造方法，必须是构造方法中的第一个语句。
2.super只能出现在子类的方法或者构造方法中。
3.super 和 this 不能够同时调用构造方法。（因为this也是在构造方法的第一个语句）
【super 和 this 的区别】
1.代 表 的 事 物 不 一 样 :
this：代表所属方法的调用者对象。
2.使用前提不一致：
this：在非继承的条件下也可以使用。
3.调用构造方法：
this：调用本类的构造方法。

方法重写

方法的重写（override）
1.方法重写只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载，不 能被重写.
2.静态方法不能重写
1.父类的静态方法不能被子类重写为非静态方法 //编译出错
2.父类的非静态方法不能被子类重写为静态方法；//编译出错
3.子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖)

//A类继承B类 A和B中都一个相同的静态方法test
B a = new A();
a.test();//调用到的是B类中的静态方法test
A a = new A();
a.test();//调用到的是A类中的静态方法test

可以看出静态方法的调用只和变量声明的类型相关
这个和非静态方法的重写之后的效果完全不同

私有方法不能被子类重写，子类继承父类后,是不能直接访问父类中的私有方法的,那么就更谈不上重写了。

public class Person{ 
	private void run(){}
}
//编译通过,但这不是重写,只是俩个类中分别有自己的私有方法	
public class Student extends Person{
	private void run(){}
}

重写的语法
1.方法名必须相同
2.参数列表必须相同
3.访问控制修饰符可以被扩大,但是不能被缩小： public protected default private
4.抛出异常类型的范围可以被缩小,但是不能被扩大 ClassNotFoundException —> Exception
5.返回类型可以相同,也可以不同,如果不同的话,子类重写后的方法返回类型必须是父类方法返回类型的子类型 例如：父类方法的返回类型是Person,子类重写后的返回类可以是Person也可以是Person的子类型
注：一般情况下,重写的方法会和父类中的方法的声明完全保持一致,只有方法的实现不同。(也就是大括 号中代码不一样)

为什么要重写？
子类继承父类,继承了父类中的方法,但是父类中的方法并不一定能满足子类中的功能需要,所以子类中需 要把方法进行重写。

总结：

方法重写的时候，必须存在继承关系。 方法重写的时候，方法名和形式参数 必须跟父类是一致的。
方法重写的时候，子类的权限修饰符必须要大于或者等于父类的权限修饰符。( private < protected < friendly < public )
方法重写的时候，子类的返回值类型必须小于或者等于父类的返回值类型。( 子类 < 父类) 数据类型没有明确的上下级关系
方法重写的时候，子类的异常类型要小于或者等于父类的异常类型。

多态(polymorphism)

多态性是指允许不同类的对象对同一消息作出响应。
多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
一个对象的实现类型虽然是确定的,但是这个对象所属的类型可能有很多种。

Student	s1	=	new	Student();
Person	s2	=	new	Student();
Object	s3	=	new	Student();

//静态动物类
abstract class Animal{
    String name;
     static String color="动物色"; //设置默认颜色
    public Animal(String name){
        this.name=name;
    }
    public abstract void run();
    public  void eat(){ //创建一个动物吃东西的方法
        System.out.println("吃东西");
    }
}

//老鼠
class Mouse extends Animal{
    static String color="老鼠色";
    public Mouse(String name){
        super(name);
    }
    public void run(){
        System.out.println(name+"四条腿，灵活的走位");
    }
    public  void eat(){
        System.out.println("老鼠在吃东西");
    }
    public void dig(){//老鼠特有的方法
        System.out.println("老鼠在打洞");
    }
}
//创建一个鱼   外部类
class Fish extends Animal{
    public Fish(String name){
        super(name);
    }
    public void run(){  //鱼特有的动作
        System.out.println(name+"在海中快速的游行");
    }
}

public class Demo4 {//多态

    public static void main(String[] args) {
        Animal a=new Mouse("老鼠" );
        System.out.println(a.color);
        a.eat();
    }
}

编译看左边，运行不一定看右边。

编译看左边的意思：java 编译器在编译的时候会检测引用类型中含有指定的成员，如果没有就会报错。子类的成员是特有的，父类的没有的，所以他是找不到的。

2、重写、重载和多态的关系
重载是编译时多态

调用重载的方法,在编译期间就要确定调用的方法是谁,如果不能确定则编译报错

重写是运行时多态

调用重写的方法,在运行期间才能确定这个方法到底是哪个对象中的。这个取决于调用方法的引用,在运行 期间所指向的对象是谁,这个引用指向哪个对象那么调用的就是哪个对象中的方法。(java中的方法调用, 是运行时动态和对象绑定的)

3、多态的注意事项

1.多态是方法的多态，属性没有多态性。
2.编写程序时，如果想调用运行时类型的方法，只能进行类型转换。不然通不过编译器的检查。但是 如果两个没有关联的类进行强制转换，会报：ClassCastException。 比如：本来是狗，我把它转成猫。就会报这个异常。
3.多态的存在要有3个必要条件：要有继承，要有方法重写，父类引用指向子类对象

4、多态存在的条件

1.有继承关系
2.子类重写父类方法
3.父类引用指向子类对象

补充一下第二点，既然多态存在必须要有“子类重写父类方法”这一条件，那么以下三种类型的方法是没 有办法表现出多态特性的（因为不能被重写）：

1.static方法，因为被static修饰的方法是属于类的，而不是属于实例的
2.final方法，因为被final修饰的方法无法被子类重写
3.private方法和protected方法，前者是因为被private修饰的方法对子类不可见，后者是因为尽管被protected修饰的方法可以被子类见到，也可以被子类重写，但是它是无法被外部所引用的，一个不能被外部引用的方法，怎么能谈多态呢

5、方法绑定(method binding)

执行调用方法时，系统根据相关信息，能够执行内存地址中代表该方法的代码。分为静态绑定和动态绑 定。 静态绑定：
在编译期完成，可以提高代码执行速度。 动态绑定： 通过对象调用的方法，采用动态绑定机制。这虽然让我们编程灵活，但是降低了代码的执行速度。这也
是JAVA比C/C++速度慢的主要因素之一。JAVA中除了final类、final方、static方法，所有方法都是JVM在
运行期才进行动态绑定的。 多态：如果编译时类型和运行时类型不一致，就会造成多态。

6、instanceof和类型转换
1.instanceof

public class Person{ 
	public void run(){}
	}
	public class Student extends Person{
	}
	public class Teacher extends Person{
	}
	public static void main(String[] args) {
	
	Object o = new Student();
	System.out.println(o instanceof Student);//true 
	System.out.println(o instanceof Person);//true
	System.out.println(o instanceof Object);//true 
	System.out.println(o instanceof Teacher);//false
	System.out.println(o instanceof String);//false
	
	Person o = new Student();
	System.out.println(o instanceof Student);//true 
	System.out.println(o instanceof Person);//true 
	System.out.println(o instanceof Object);//true 
	System.out.println(o instanceof Teacher);//false
//编译报错
	System.out.println(o instanceof String);

	Student o = new Student(); 	
	System.out.println(o instanceof Student);//true
	System.out.println(o instanceof Person);//true
	System.out.println(o instanceof	Object);//true
//编译报错		
	System.out.println(o instanceof	Teacher);
//编译报错		
	System.out.println(o instanceof	String);

 }
}

System.out.println(x instanceof Y);
该代码能否编译通过,主要是看声明变量x的类型和Y是否存在子父类的关系.有”子父类关”系就编译通过,
没有子父类关系就是编译报错.

System.out.println(x instanceof Y);
输出结果是true还是false,主要是看变量x所指向的对象实际类型是不是Y类型的”子类型”.

2.类型转换

public class Person{
	public void run(){} 
}
public class Student extends Person{
	public void go(){} 
		}
public class Teacher extends Person{
	}

【为什么要类型转换】

//编译报错,因为p声明的类型Person中没有go方法
Person p = new Student();
p.go();
//需要把变量p的类型进行转换
Person p = new Student();
Student s = (Student)p;
s.go();
或者
//注意这种形式前面必须要俩个小括号
((Student)p).go();

【类型转换中的问题】

//编译报错,因为p声明的类型Person中没有go方法
Person p = new Student();
p.go();

//需要把变量p的类型进行转换
Person	p = new Student();
	Student s = (Student)p;
	s.go();
	
//注意这种形式前面必须要俩个小括号
((Student)p).go();

【类型转换中的问题】

//编译通过 运行没问题
	Object o = new Student();
	Person p = (Person)o; 
//编译通过 运行没问题
	Object o = new Student();
	Student s = (Student)o;

//编译通过,运行报错
	Object o = new Teacher();
	Student s = (Student)o;

即:
X x = (X)o;
运行是否报错,主要是变量o所指向的对象实现类型,是不是X类型的子类型,如果不是则运行就会报错。

【总结】

1、父类引用可以指向子类对象，子类引用不能指向父类对象。
2、把子类对象直接赋给父类引用叫upcasting向上转型，向上转型不用强制转型。如Father father = new Son();
3、把指向子类对象的父类引用赋给子类引用叫向下转型（downcasting），要强制转型。
如father就是一个指向子类对象的父类引用，把father赋给子类引用son 即Son son =（Son） father；
其中father前面的（Son）必须添加，进行强制转换。 4、upcasting 会丢失子类特有的方法,但是子类overriding
父类的方法，子类方法有效 5、向上转型的作用，减少重复代码，父类为参数，调有时用子类作为参数，就是利用了向上转型。这样
使代码变得简洁。体现了JAVA的抽象编程思想。