什么面向对象

什么面向对象:
个人分析觉得：在程序设计里,面向对象是一种相对说法，相对于面向过程而言的；
面向“对象"：即重点在于“对象"；而面向过程：则重点在于“过程”，简单说：就是我我们看待事物在眼光上注重点不一样；比如说：我们评判一个女孩漂亮与否，有的人看重外表，有的人则看重“心灵”，只是侧重点不一样。
举个例子：把大象装进冰箱！
                
                    面向过程                                      面向对象
            （注重一系列动作即过程）                       （注重动作所操作的承受者［“对象”］）
                     
                “打开”冰箱                                “冰箱”打开
                “装入”大象                                “大象”装入
                “关闭”冰箱                                “冰箱”关闭

类：通俗的说类就是“一类事物的简称”，并且这些事物至少具有一点“共同的”特征.比如说：动物就是一个类

对象：就是某一类中一个具体的（就是可以具体描述出来的）东西，比如：动物(类)里的“狗”就是一个对象。(个人觉得对象相对于类而言的,因为狗又可以分好多种，‘狗’相对于‘哈士奇’是一个类,‘哈士奇’是‘狗’类的一个具体对象)

在生活中就拿描述汽车来说，我们都知道汽车都有4个轮子； 都有跑的功能
可以如下描述:
    类     汽车                    
    属性： 4个轮
    功能： 跑
那么怎么在Java中描述汽车这类呢？
class car{
    int wheel=4;//属性： 4个轮
    void run(){//方法(功能)： 跑
    System.out.println("是汽车都会跑");
    }
}
那么可见“出租车”应当是“汽车”这类的一个具体化（实实在在的例子即“实例”）对象，那自然出租车也就具备了汽车这类所具备的“共有”属性功能！
如何创建一个出租车对象呢？java中通过new关键字来创建一个类的实例即对象，也叫类的实例化，就是把类具体化成一个实例嘛！
格式：类名  对象名 =  mew 类名  ()  
      Car    texi =   new  Car();
创建了“出租车”对象（实例）之后那么它也就有了如下“自己”的属性和功能。
    int wheel=4;//属性： 4个轮
    void run(){//功能： 跑
            System.out.println("我是出租车我也会跑");
    }
我们如何来访问对象中的它自己的属性和方法呢？
格式：对象.属性；        对象.方法名();   这一点也验证了面向对象编程的侧重点在于“对象”上；
      texi.wheel;            texi.run()
*********************************************************************************************************************************************************************************************************************************************
 
1.封装：
从字面可以解读为将东西封起来再装好。要想拿到里面的东西就得有相应的方法打开，才能拿到。
举例来说：一个房间的门如果没有上锁，那么大家都可以进去拿东西，但现在我们不想让谁都进来拿东西，我们可以将房门上锁，只对外提供一把钥匙，只有有钥匙的人才能进来，这就是“封装”现象！

在java程序中，“封装”现象如何实现呢？
可以这样实现：将类中的一些属性和方法用private关键字修饰，将他们“私有化（即不对外直接公开）”,使外部其他类不能通过创建该类对象或通过类名直接访问这些属性和方法;只对外提供公有的方法，外部其他类必须通过该类对外提供的公有方法来访问该类的相应成员；例如：
class Person{
   private String name;//将name属性私有化（封装）［相当于了上锁］使外部其他类不能直接访问到
    public SetName(String name){//对外提供公有方法（相当于房门钥匙）供外部其他类访问到本类属性
        this.name=name;
    }

}

2.继承：
    从字面来说继承就是子父类关系的简称 ，就是儿子（女儿也行，好吧）会继承老爸的一些属性和行为
在java中如何描述继承关系呢？
  注意：   第一得知道在java中继承是类与类之间或者是接口与接口之间才有继承关系；通过extends关键字来描述继承关系
例如：老爸这个类
class Dad{
    String sex=man;
    void smoke(){
        System.out.println("老子会抽烟！");    
    }
}
那么我们怎么来让儿子这个类继承老爸这个类呢？
class Son extends Dad{//通过extends关键字儿子这个类就继承老爸这个类了
    String name;//定义自己的属性
    String sex=man;//继承过来的属性，无须再定义，这里写出来是为了好理解
    void smoke(){//继承过来的方法，无须再定义，这里写出来是为了好理解
        System.out.println("老子会抽烟！");    
    }
    void playBall(){//定义自己的方法
        System.out.println("儿子即会打球又会抽烟！");    
    }
    void somke(){//重写的方法
        System.out.println("我不抽20块以下的烟");
    }
    void smoke(int n){//重载的方法
    System.out.println("我抽了+n+"年的烟了");
    }
}
那么具有继承关系的两个类有什么特点呢？
1）子类会将父类的属性和方法继承过来，当然子类也可以自己定义的属性和方法
2）当子类自己定义的方法和父类继承过来的方法相同时会发生“重写“现象！
3）父类用private关键字私有的方法是不能被继承的！
4）子类可以使用super访问父类的属性和方法
5）子类通过重写父类方法，修改父类的功能
6）子类构造器一定调用父类的无参构造器
7）构造器不能继承

3.多态：
字面意思就是多种形态,也就是说一种事物同时局部多种形态.
注意：要出现多态情况，那么类和类之间一定得是继承关系，或者类和接口是实现关系
我觉得：在java中多态是相对于一个对象而言的，就是父类型引用变量引用子类对象，并且父类型引用变量可以接受不同子类的对象
例如：拿上面的举例
 Dad uncle=new Son();父类引用变量uncle即具备Son类的成员又具备父类的成员；这也称为“向上造型”；
多态时的特点
1）多态时访问成员变量，如uncle.name;
编译时看等号左边，父类有该成员变量则编译通过，否则编译出错！
运行时也看等号左边，有则运行结果
2）多态时访问方法,如uncle.smoke()
编译时看等号左边，父类有该成员方法则编译通过，否则编译出错！
运行时看等号右边，父类有该方法，子类没有该方法执行父类方法；父类有该方法，子类也有该方法执行子类方法
3）多态时访问静态方法
编译运行都看等号左边
******************************************************************************************************************************************************************************************************************************************************************

 4.抽象(有争议)： 
什么是抽象？
抽象就是不具体 。
一般我们把不能具体描述的东西约定俗成为“抽象”的东西 。例如：我们说一个人长得很“抽象”,n你想你能具体形容描述出来么？
在JAVA中如何描述抽象这个概念呢？
我觉得在java中抽象类是由抽象方法而衍生出来的，为什么呢？
    因为Java规定一个类中定义了抽象方法那这个类就跟着必须定义为抽象类，而不是因为先定义抽象类再跟着规定抽象类中的方法必须是抽象的，可能最后理解的结果是一样的但性质是不一样的（个人理解）简单说：就是有抽象方法的类一定是抽象类，但是抽象类中不一定都是抽象方法，也可以有具体方法。
首先就是当我要在一个类定义一个方法时，暂时我不知道该方法具体功能是什么；等我想好了我在用他实现一个功能时我再具体描述他功能，这样我们就可以将这个方法用abstract关键字修饰定义为抽象方法
（还有一点也就是什么时候定义抽象类的？也可以说抽象类是向上抽取而来的，就是几个类据有共同的属性和方法，不想每个类都定义一次，那么定义一个公有类（即抽象类）其他类只要继承抽象类再重写方法就行！）
例如：我有一百块钱，现在我不知道怎么用，等我想好了在具体怎么用！
abstract class Money{//因为有了抽象方法所以必须定义为抽象类
    public abstract void buySomthing();//现在不知道怎么用，那就把它的功能代码体去掉
}
//现在我饿了，想买东西吃了，我就知道怎么用了
class Hungry extends Money{
    void buySomething(){
        System.out.println("我饿了，现在我要买东西吃！")
    }
}
抽象类的特点
1）抽象类不能实例化
2）抽象类可以继承抽象类
3）继承抽象类必须得重写抽象方法

5.抽象类，接口，普通类 的不同点和相同点？
  1）不同点： 
            普通类             接口                                     抽象类
可以直接实例化对象        不可以直接实例化对象                                不可以直接实例化对象    
可以定义任何成员            只能定义抽象成员方法和常量                     成员方法必须定义为抽象其他和普通类相同
可以被继承                            类可以实现接口，且可以实现多个接口         可以被继承  
                        接口可以继承多个接口                    抽象类有构造方法，接口中不能有
                                                           抽象类有普通成员变量，接口中没有
                                                           抽象类可以有非抽象方法，接口中不能有 
                                                          抽象类可以用public、protected修饰，接口中只能public（默认public）
                                                          抽象类包含静态方法，接口中没有
                                                         接口中的变量只能是public static final，抽象类中可以是任意类型修饰 

2)相同点：都可以用于描述(封装)事物的,

内部类分为哪几种？分别如何创建对象？
分为 局部内部类，匿名内部类...3种 

1）外部类名.内部类名 对象名＝new 外部类名（）.new 内部类名 （）
2）外部类名.内部类名 对象名＝外部类名.new 内部类名 （）
3）....不记得了第3种
匿名内部类 
二、集合 
集合的定义？
集合：用来保存一组数据的数据结构 
集合的父接口，实现接口，实现类，实现类的常用方法是什么？(建议以树状图画出来，便于加深印象)。
                                                              Collection                                                                
                                                    list                     set    
                                        Arraylist   LinkedList      HashSet  TreeSet 


1.List集合
List集合的特征是元素可重复且有序 ；我们可以把他看成是一个动态数组，一般通过下标访问
ArrayList和LinkedList最常用的两个子类实现
1)list可以使用for循环遍历
for（int i=;i<list.size();i++?){
    list.get(i);
}
2)list的浅层复制
调用ArraryList.clone()方法 
注意：不能使用list.clone(),clone()方法是Object类的方法,list是接口是不能继承Object类的

2.Set集合：
不重复且无序集
遍历set只能迭代器，用迭代器遍历集合遵循的操作原则:先问后取。问一次取一次。
Iterator<E> it=set.iterator();
while(it.hashnext()){
    E e=it.next();
}
3)map表
Map存储数据使用key-value(键-值)对的形式存储数据的。 
对于Map而言，要求key值是唯一的。value值可以重复 
获取数据时，使用key可以获取其对应的value
遍历map有3种方法
1）遍历key
  Set<String> keySet = map.keySet(); 
      for(String key:keySet){ 
          System.out.println("key：" + key); 
          //可以根据每一个key获取其对应的value值 
          int value = map.get(key);
2)遍历value
Collection<Integer> values = map.values(); 
        Iterator<Integer> it = values.iterator(); 
        while(it.hasNext()){ 
            int value = it.next();//不能采用 map.next() 
            System.out.println("value:" + value);
注意：通过迭代器在遍历集合的过程中，不能通过集合(即不能采用 map.next())去改变集合元素数量
3)遍历键值对 
    Set<Entry<String,Integer>> entries= map.entrySet(); 
        for(Entry<String,Integer> entry : entries){ 
            //获取一组键值对的键和值 
            String key = entry.getKey(); 
            int value = entry.getValue(); 
            System.out.println(key + "=" + value);

Collection接口方法的定义
这里我主要列举 Iterator iterator()方法的使用
Collection提供的方法 Iterator iterator()方法来获取迭代器
Iterator是一个接口，定义了遍历集合应有的方法。
使用迭代器遍历集合遵循的操作原则:先问后取。问一次取一次。 
   问：boolean hashNext() 
  取：Object next() 
迭代器可以将取出的数据删除掉 
删：remove() 将当前获取的元素删除掉。 
注意：1)删除的是next()取出的元素。且只能删除一次！ 
       2)调用1次next()后只能调用一次remove()!