javase(5)_面向对象

一、概述

1、面向对象是一种思想,让我们由执行者变成指挥者,执行者是面向过程,指挥者是面向对象.例如人开冰箱门,开冰箱门这个动作应该属于门而不是人,冰箱自己最清楚门应该怎么开,人只是调用了冰箱的这个动作.
2、面向对象开发例子 1.电脑坏了,找个修电脑的人,我们调用修电脑这个人修电脑的功能即可,自己不需要知道具体怎么修;2.公司老板找人完成软件开发...
3、开发的时候先想是否java已经实现了这个功能,找这个对象拿过来用,如果没有,自己造一个对象来用,自己能用别人也能用,开发就是找对象,找不到就建对象,然后用对象.
4、类和对象的关系,类是事物的描述(属性,行为),对象是实实在在的个体.
5、引用传递和值传递的区别.
6、成员变量和局部变量区别： 作用范围,存储位置,有无默认值.
7、面向对象三个特征: 封装,继承,多态.

面试题:讲下什么是面向对象?

直接举例:面向对象是相对面向过程说的(比如C语言这种一步一步写),比如说电脑坏了,找个修电脑的人,我们调用修电脑这个人修电脑的功能即可,自己不需要知道具体怎么修，C语言这种思想的话就需要自己拆开电脑一步一步修,开发的时候先想是否java已经实现了这个功能,找这个对象拿过来用,如果没有,自己造一个对象来用,自己能用别人也能用,开发就是找对象,找不到就建对象,然后用对象.

8、访问权限控制：public、protected、包访问权限、private,控制对成员的访问权限有两个原因:1、为了使用户不要触碰那些他们不该触碰的部分,这些对于类内部的操作是必要的,但是他不属于客户端程序员接口的一部分.2、为了让类库设计者可以更改类的内部工作方式,而不必担心会对客户端程序员产生重大影响.

二、封装

1、对外提供简单接口,封装细节 ,私有是封装的一种表现形式.
2、构造函数可以私有化一般是为了安全.
3、构造函数给不同的对象进行初始化,构造代码块是给所有的对象进行统一初始化(可以把构造函数中共同的东西提到这里).

三、this

1、this 代表它所在函数当前对象的引用,但凡本类功能内部调用本类对象都使用了this表示,因为在写类的时候对象还没定义.
2、this 用在构造函数之间相互调用,只能用this语句,且只能写在第一行.
3、类中方法之间可以互相调用,静态方法省略的是类名,非静态省略的是this.

四、static

1、只能修饰成员变量和成员方法,不能修饰局部变量.
2、随着类的加载(创建类对象或调用类的静态方法,类名 变量=null,不会加载)而加载,随类消失而消失,只执行一次(生命周期比非静态成员变量长).
3、1.优先于对象的存在 2.所有对象共享 3.类直接调用 4.放在方法区或叫数据区
4、静态方法中不能访问非静态变量;静态方法中不能使用this,supper.
5、什么时候使用static?
对于成员变量一般是需要共享的数据；对于成员方法,一般是该方法没有封装该类的特有属性时(即非静态成员变量),例如工具类Array中的方法.

五、初始化顺序

加载类的时候->静态变量->静态代码块(给类初始化,可以用来给静态变量赋值)->非静态成员变量->代码块(给对象初始化,不可以给静态变量赋值)->特定构造函数.

六、继承

1、提高代码复用性,类之间产生关系,父类提供子类共性的东西.
2、不支持多继承,有安全隐患,因为当多个父类中定义相同方法时,子类对象调用不确定调用哪个,支持多层继承,祖孙三代.
3、super 父类对象的引用,如果子类和父类中出现同名非私有成员变量时,子类访问本类中的变量用this,父类要访问本类中的变量用super,super的用法和this几乎一样.
4、函数的另一个特性重写(覆盖),子类和父类中函数一模一样(子类权限必须大于父类权限),子类对象调用,会调用子类的方法；函数的另一个特性是重载.
5、子类所有的构造函数默认第一行是super(),写在第一行;和this用法一样 super(4)调用父类参数传递4的构造函数,加括号掉用构造函数,不加括号代表当前对象和父类的引用.

七、final

继承的一个弊端是打破类的封装性,因为它的方法可以被重写, 因此出现了final,修饰类不能被继承(String类是final),修饰方法不能被重写,修饰变量是一个常量,只能赋值一次(作为函数的形式参数时函数被多次调用可以赋不同的值,这是俩回事).常量字母大写,单词间用_,相当于一个锁变量块,此时还往往加上public static 用来共享.

八、抽象类

1、抽象方法(没有方法体)只能放在抽象类中.
2、抽象类和抽象方法都用abstract修饰.
3、抽象类不可以new因为调用抽象方法没意义.
4、如果子类只覆盖部分抽象方法,那子类还是抽象类因为继承了其他抽象方法,抽象类可以有非抽象方法,抽象类通过继承实现.
5、java中有没有抽象方法的抽象类,仅仅是为了不让实例化.

九、接口

一个例子说明使用接口的好处：
cpu和主板,之前cpu是直接焊接在主板上,现在主板厂商暴露针脚,只要cpu厂商按这个针脚做的cpu都可以直接装到主板上使用,这样以后电脑升级时,可以直接更换cpu.
1、接口编译也是class文件,接口中成员有固定修饰符,变量是public static final,方法是public abstract.
2、接口不能建对象,子类必须全部覆盖接口的方法,否则子类是抽象类.
3、类与类之间是继承关系,类与接口之间是实现关系,接口与接口之间是继承关系.
4、类可以同时继承一个类和实现多个接口 (只有接口和接口之间存在多继承,类之间只支持单继承).
5、接口特点：对外暴露规则,提高程序功能扩展 ,降低耦合性.

十、多态

1、重载和重写都是多态的体现,父类引用指向子类对象 ,提高代码复用性(传入谁谁运行,以前指挥一个对象去做事情,现在指挥一批对象去做事情,这里面有共性事物的抽象).
2、多态前提,1.存在继承或者实现;2.存在覆盖(只能使用父类的引用去访问父类的成员).
3、Animal a = new Cat(); //向上转型,Cat c = (Cat)a; //如果想使用猫的特有方法时,向下转型, 类似于int和byte之间的相互转换,Animal a = new Aniaml();Cat c = (Cat)a; 这是错的,此时Cat还不存在.
4、instanceof 判断对象的所属关系,当想用子类特有方法时可以用.

testInstanceof(new Dog());
void testInstanceof(Animal a){ //当子类个数有限时这么用,多的话也比较麻烦,if(a instanceof Animal) 无意义.
　　　if(a instanceof Cat){
　　　　　a.catchMouse();
　　　}else if(a instanceof Dog){
　　　　 a.kanjia();
　　　}
 }

5、多态中(非静态)成员函数的特点：
编译期：检查引用型变量所属的类中是否有调用的方法,没有编译失败
运行期：检查对象所属的类中是否有调用的方法,没有抛异常
简单就是编译看左边,运行看右边.
6、面试题： (一般只出现在面试时, 也就是覆盖一般不会出现在静态成员上,因为它是静态绑定 )
当多态情况下,父类和子类中出现同名变量(非静态)时,看左边, Fu f = new Zi(); f.num 调用Fu的num,多态情况下,静态成员函数和静态变量时,只看左边.

十一、内部类

1、当描述事物时,事物内部还有事物用内部类(一般可以被private修饰), 可以直接继承外部类.
2、内部类可以直接访问外部类的任何成员和方法,包括私有,外部类要访问内部类,必须定义内部类的对象.
3、内部类定义在局部时,可以访问外部类中的成员,还持有引用,只能访问被final修饰的局部变量(成员变量都可以).
4、匿名内部类前提： 必须继承或者实现一个接口,格式：new 父类或者接口{定义子类内容}，其实匿名内部类就是一个匿名子类对象.
5、匿名内部类里面最多写一俩个方法，多了阅读性太差.
6、springJDBC的RowMapper使用内部类实例：

    public List<User> getUserByName(String username) {
         String sql = "select * from t_user where username = ?";
         Object[] params = new Object[] { username };
         List<User> users = null;
        /*使用接口实现类 */
         users = jdbcTemplate.query(sql, params, new UserRowMapper());
        /**
         * 使用匿名内部类
         * 如果UserRowMapper类只使用一次，单独为其创建一个类多余，可以使用匿名类
         * 省略了书写一个实现类
         */
         users = jdbcTemplate.query(sql, params,
                   new RowMapper<User>() {
                        @Override
                   public User mapRow(ResultSet rs, int rowNum) throws SQLException {
                           　 User user = new User();
                             user.setId(rs.getInt("id"));
                             user.setUsername(rs.getString("username"));
                             user.setPassword(rs.getString("password"));
                       return user;
                         }
                });
        return (users != null && users.size() > ) ? users : null; }  

        public class UserRowMapper implements RowMapper<User> {
            @Override
            public User mapRow(ResultSet rs, int rowNum) throws SQLException {
                User user = new User();
                user.setId(rs.getInt("id"));
                user.setUsername(rs.getString("username"));
                user.setPassword(rs.getString("password"));
                return user;
            }
        }  

十二、String类

1、String对象是不可变的,String类中每一个看起来会修改String值的方法,实际上都是创建了一个新的String对象,以包含修改后的字符串内容.

2、不可变性带来的效率问题，例：String s="a"+"def"+44;过程会先生成一个中间对象以包含a和def，再生成对象包含所有，此方式会产生一大堆需要垃圾回收的中间对象。这种情况要使用StringBuilder,以前用的是StringBuffer是线程安全的.

3、使用format进行C语言风格的格式化输出，排版控制能力更强，代码简单.例：

public class TestFormat {
    //常用的类型转换 ：%d(整数) %c(Unicode字符) %b(boolean值) %s(String) %f(浮点数)
    //例1
    public static void test1() {
        System.out.format("sdf1:[%c %f]\n", ,3.2);
    }
    //例2
    public static void test2() {
        Formatter f = new Formatter(System.out);
        f.format("c: %s\n","abc");
        f.close();
    }
    //例3 当只需要一次format时可以使用String的静态方法format
    public static void test3() {
        String.format("%s?type=%d", "http://vip.ku6.com", );
    }
}

十三、类型信息

1、java如何让我们在运行时识别对象和类的信息，主要两种方式：1、传统的RTTI(Run-Time Type Identification),它假定我们在编译时已经知道了所有的类型，2、反射机制，它允许我们在运行时发现和使用类的信息.

2、要理解RTTI在java中的工作原理，首先必须知道类型信息在运行时是如何表示的，这项工作是由Class对象完成的，它包含了与类有关的信息，事实上，Class对象就是用于创建类的所有常规对象的，Java使用Class对象来执行其RTTI。每当编译了一个新类，就会产生一个Class对象。为了生成这个类的对象，运行这个程序的JVM将使用类加载器的子系统。

3、如果你想在运行时使用类型信息，就必须首先获得对恰当Class对象的引用，Class.forName()就是实现此功能的便捷途径，因为你不需要为了获得CLass引用而持有该类的对象，但是如果有了类的对象就可以通过getClass()方法来获得Class引用，这个方法属于Object的一部分，还有一种方式:类名.class。