面向对象
刚刚开始接触编程的时候,我们最常听到的是面向过程编程,面向对象编程。这里面向过程编程我就不在描述,主要描述面向对象也就是 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 &¶ms!= 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
** 封装的作用和意义**
顺带这块将一下方法重载
类中有多个方法,有着相同的方法名,但是方法的参数各不相同,这种情况被称为方法的重载。方法的重载 可以提供方法调用的灵活性。
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来 表示。
3.子类和父类之间,从意义上讲应该具有"is a"的关系.
4.类和类之间的继承是单继承
5.父类中的属性和方法可以被子类继承
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就表示访问或调用父类中的属性和方法。
- 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");
}
}
方法重写
//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(){}
}
总结:
多态(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();
}
}
编译看左边,运行不一定看右边。
2、重写、重载和多态的关系
重载是编译时多态
重写是运行时多态
3、多态的注意事项
4、多态存在的条件
补充一下第二点,既然多态存在必须要有“子类重写父类方法”这一条件,那么以下三种类型的方法是没 有办法表现出多态特性的(因为不能被重写):
5、方法绑定(method binding)
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();
【类型转换中的问题】
//编译通过 运行没问题
Object o = new Student();
Person p = (Person)o;
//编译通过 运行没问题
Object o = new Student();
Student s = (Student)o;
//编译通过,运行报错
Object o = new Teacher();
Student s = (Student)o;
【总结】