JAVASE学习总结（一）

     JAVA语言是一种面向对象的语言。要使用JAVA进行面向对象编程，首先要建立面向对象的思想。OOP的基本思想是把问题看成若干个对象组成的，这些对象之间是独立的 ，但又可以相互配合、连接和协调，从而共同完成整个程序要实现的任务和功能。面向对象的三大特征：封装、继承、多态。
    一、 类和对象：类是具有相同属性和方法的一组对象的集合；类定义了对象拥有的属性和方法。对象则是类的一个实例。
    创建 对象的语法：
        类名    对象名   =     new    类名();
    其中new 为关键字；左边的类名为对象的数据类型；右边的类名()为类的构造方法。
    
    要引用对象的属性和方法，需要使用“.”。            即：对象名.属性；          对象名.方法()
    
     类成员主要包含两部分：成员方法和成员变量。
    方法的 重载：
                           特点：1.在同一个类中。    2.方法名相同。    3.参数的类型或者个数不同。
                           优点：对一般方法的升级，可以根据参数的不同，采用不同的实现方法。
                            注：  构造方法也可以重载。
                            方法是否重载只看方法参数的类型或者个数是否相同，不同即为重载。
     成员变量：
                            成员变量也就是类的属性，直接在类中定义的变量，它定义在方法的 外部。
                            声明成员变量时可以不赋初始值，也可以赋初始值。
     局部变量：
                            局部变量就是定义在方法 内部的变量。
                            局部变量必须 初始化后才可以使用。
                            成员变量和局部变量的 区别：
                            1.作用域不同。局部变量的作用域仅限于定义它的方法，该方法外无法访问它。成员变量的作用域在整个类中都
                               是可见的，所有成员方法都可以使用它，如果访问权限允许，还可以在类外部使用成员变量。
                            2.初始值不同。对于成员变量，如果在定义时没有赋初始值，JAVA 会给它赋默认值。但是JAVA不会给局部变量 
                                赋初始值，因此局部变量必须赋值后才能使用。
                            3.在同一个方法中不允许有同名的局部变量。在不同的方法中可以有同名的局部变量。
                            4.局部变量可以和成员变量同名，并且在使用时，局部变量具有更高的优先级。
    数据类型：
                            JAVA中有两大数据类型： 基本数据类型和 引用数据类型。
                            二者的内存分配和传参 区别：
                            1.对于基本数据类型，不同的变量会分配不同的内存（栈内存）空间，并且存储空间中存储的是该变量的值。赋
                               值 操作时传递的是变量的值。改变一个变量的值不会影响另一个变量的值。
                            2.对于引用数据类型，是现在栈内存中分配空间存放一个引用变量名，然后在堆内存中开辟空间存放数据，最后 
                               让引用变量名指向堆内存中数据的引用（内存地址。）赋值操作时传递的是引用（内存地址）。当两个引用变 
                               量同时指向堆内存中的一个引用时，改变其中一个变量的值，另一个也随其改变。
     构造方法：
                            构造方法的主要作用是对对象进行数据初始化。
                            特点：
                                        1.构造方法 没有返回值。（不写任何返回值类型。）
                                        2.构造方法的方法名和类名相同。
                                        3.当没有编写自定义构造方法的时候，JAVA会自动添加默认构造方法，默认构造方法没有参数。如果自
                                            定义了一个或多个构造方法，JAVA就不会自动添加默认构造方法。
                                        4.构造方法同样可以重载。
     this关键字：
                           this关键字是对一个对象的默认引用。每个实例方法内部，都有一个this引用变量，指向调用这个方法的对象。
                           this的使用：                   
                                            1.使用this调用成员变量，解决成员变量和局部变量的同名冲突。
                                            2.使用this调用成员方法。（此处this可以省略不写）
                                            3.使用this调用重载的构造方法，只能在构造方法中使用，而且必须写在构造方法中的第一句。


    JAVA面向对象的三大特性之一： 封装
                            封装的实质就是将类的状态信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对
                    隐藏信息的操作和访问。

                    封装的好处：隐藏类的实现细节；让使用者只能通过程序员设计的方法来访问数据，可以更加方便的加入存取控制语
                                        句，限制不合理操作。

                    封装的步骤：
                                        1.修改属性的可见性。（将类中属性的public修改成private）
                                        2.设置setter()/getter()方法。
                                        3.利用条件判断语句在setter()/getter()方法中设置操作限制。
                    JAVA中的 包（ package）：
                                         JAVA中的包机制其实也是封装的一种形式。
                                        包的主要作用：
                                                                1.包将类组合成较小的单元（类似于文件夹），易于找到和使用相应的类文件。
                                                                2.防止命名冲突。
                                                                3.包允许在更广的范围内保护类、数据和方法，可以在包内定义类。
     s tatic关键字：
                            当一个类中所有对象需要共同使用某些数据（成员）时，就需要使用static关键字修饰这些数据（成员）。
                            使用static修饰的成员可以通过类名加“.”直接调用，不需要创建类的对象。
                            1.static修饰的属性称为静态变量或者类变量，没有修饰的称为实例变量。
                            实际开发中，static关键字修饰属性最常用的场景就是定义使用final关键字修饰的常量。使用final修饰的常量在整
                            个程序运行时都不能改变，和具体的对象没有关系，因此用static修饰。如：static final int LIFE = 1;
                            2.static修饰的方法称为静态方法或者类方法，没有修饰的称为实例方法。
                             静态方法中不能直接访问实例变量和实例方法；但在实例方法中可以直接调用该类中定义的静态变量和静态方法


    JAVA面向对象的三大特性之二： 继承
                        定义：通过从现有的类中继承其属性和方法，来充实自身的内容，这种现象和行为称为继承。这是新类称为子类，
                                   现有的 类称为父类。
                        作用：使得代码可以重用，增加软件的可扩充性。
                        特点：1.JAVA中的类只支持单继承，就是每个类只能有一个直接父类。（接口可以多继承。）
                                   2.无法继承父类的构造方法。
                                       a. 如果父类显式的定义了自己带参数的构造方法，子类也必须显式的定义自己的构造函数，否则，无法实
                                           例化子类对象。 
                                        如：class A{
                                                            public A(int x){
                                                            }        
                                                }
                                                class B extends A{
                                                             public B(){       //如果不写该构造方法，则会导致子类B无法实例化操作。
                                                             }
                                               }
                                       b.子类在实例化时，会首先执行其父类的构造方法，然后才执行子类的构造方法。如果父类还有父类，就
                                          先执行父类的父类构造方法，然后执行父类的构造方法，再执行子类的构造方法。以此类推。
                                        如：class A{
                                                            public A(){             //子类C先调用A的构造方法
                                                                            System.out.println("hello1~~");
                                                            }
                                                }
                                                class B extends A{            //子类C再调用B的构造方法 

                                                            public B(){
                                                                            System.out.println("hello2~~");
                                                            }
                                                }
                                                class C extends B{
                                                            public C(){            //最后调用自己的构造方法 
                                                                            System.out.println("hello3~~");
                                                            }
                                                }
                                                public class Test {
                                                            public static void main(String[] args){
                                                            A a = new C();
                                                            }
                                                 }
                                    以上程序将打印出：hello1~~
                                                                    hello2~~
                                                                    hello3~~
     super关键字：
                            super只能出现在子类的方法（构造方法和普通方法）当中，不能出现在其它位置。
                            super用于访问父类的成员。如：属性、方法、构造方法。
                            super不能访问private修饰的父类成员。
                            如：

class A{

int m=0,n=0;

long f(){

return m+n;

}

}

class B extends A{

int m=1,n=1;

long f(){

long result=0;

super.m=10;

super.n=20;

result=super.f()+(m+n);

return result;

}

long g(){

long result=0;

result=super.f();

return result/2;

}

}

public class ExtendsDemo{

public static void main(String args[]){

B b=new B();

b.m=3;

b.n=7;

long resultOne=b.g();

long resultTwo=b.f();

long resultThree=b.g();

System.out.println("resultOne="+resultOne);

System.out.println("resultTwo="+resultTwo);

System.out.println("resultThree="+resultThree);

}

}

Object类：
                    Object类是所有类的父类。所有的JAVA类都直接或间接地继承了java.lang.Object类。
                    Object类定义了许多可被其它类继承的方法，比较常用的方法有以下几种，也是被它的子类经常重写的方法。
                     1.toString()                按字符串对象类型返回当前对象本身的有关信息。
                    2.equals()                  比较两个对象是否为同一个对象。

                            3.clone()                   生成当前对象的一个副本。
                          4.hashCode()           返回对象的哈希代码值。
                          5.getClass()              获取当前对象所属的类信息，返回Class对象。
                          如下为：equals()方法的重写：

class ObjEquals{

private int num;

ObjEquals (int num)    //构造方法

{

this.num = num;

}

public boolean equals(Object obj)       //equals()方法的重写。

{

if(!(obj instanceof ObjEquals))     //如果不是同一个对象，返回false

return false;

ObjEquals d = (ObjEquals)obj;      //将Object类型的obj对象赋给ObjEquals类型的d对象

return this.num == d.num;

}

}

 class ObjEqualsDemo{

public static void main(String[] args)

{

ObjEquals d1 = new ObjEquals(5);

ObjEquals d2= new ObjEquals(5); 

System.out.println(d1.equals(d2));

}

 }

继承中的方法重写：

                                        在子类中可以根据需求对从父类继承的方法进行重新编写，这称为方法的重写或者覆盖。（Overriding）
                                        方法重写的要求：
                                                                    1.重写方法名和被重写方法名必须相同。
                                                                    2.必须具有相同的参数列表。
                                                                    3.必须有相同的返回值类型。
                                                                    4.不能缩小被重写方法的访问权限。

        JAVA面向对象的三大特性之三： 多态
                                多态意味着一个特定类型的变量可以引用不同类型的对象，并且能自动地调用引用的对象的方法。
                                1. 向上转型
                                将一个父类的引用指向一个子类的对象称为向上转型。简单地说，向上转型相当于基本数据类型的自动类型转换。
                        此时，通过父类引用变量调用的方法是子类覆盖或继承父类的方法，而不是父类的方法。与此同时通过父类引用变量
                        无法调用子类特有的方法。
                               2.向下转型
                                将一个指向子类对象的父类引用赋给一个子类的引用，即父类类型转换为子类类型，称为向下转型。相当于强制
                        类型转换。当父类要访问子类特有的方法时，就需要向下转型，即强制类型转换。否则，无法访问子类特有的方法。
                               3.instanceof运算符
                               在向下转型的过程中，如果没有转换成真实的子类类型，就会出现类型转换异常，instacneof 用来进行类型的判断。

         多态的应用：
                            1.使用父类作为方法的形参
                                如：
                                                                       class Host

{

public void letCry(Animal animal)      //父类animal作为形参传递。

{

animal.cry();   //调用动物叫的方法

}

}

public class Test

{

public static void main(String[] args)

{

Host host = new Host();

Animal animal;

animal = new Dog();

host.letCry(animal);   //让狗叫

animal = new Cat();

host.letCry(animal);   //让猫叫

animal = new Duck();

host.letCry(animal);   //让鸭叫

}

}

                        2.使用父类作为 方法的返回值。

         抽象类和接口
                         1.抽象类
                                   JAVA中当一个方法被关键字 abstract修饰时，该类称为抽象方法。那么该方法所在的类也必须用abstract修饰称为
                            抽象类。
                            抽象方法的特点：用abstract修饰，没有方法体，没有{ }，方法()后有“ ；”。如：abstract void fun() ;  
                            抽象类的特点：用abstract修饰 ，抽象类不能实例化，因此不能有构造方法。 抽象类中可以有普通方法和成员变量。抽
                            象类的子类必须重写其抽象方法才能进行调用。
                         2.接口
                                    接口可以看作是一种特殊的“抽象类”。接口中的方法全部都是抽象方法。但关键字abstract可以不写。    
                                    接口也不能实例化，不能有构造方法。定义语法为：public  interface 接口名{    接口成员    }
                                    
                                    接口与抽象类的不同：访问修饰符只能是public ，且可选。接口成员可以是全局常量和公共的抽象方法。
                                    接口中不能定义变量。接口中的属性都是全局静态常量，且常量必须在定义时初始化。                                    

                                    与抽象类一样，接口的使用也必须通过子类实现，子类通过 implements关键字来实现接口。实现接口的类
                                    必须实现接口中定义的所有抽象方法。接口的实现类可以包含普通方法。
                                   
                                    接口也可以继承接口，而且可以同时继承多个接口；但接口不能继承类。
                                      
                                    一个普通类只能继承一个父类，但能同时实现多个接口，也可以同时继承抽象类和实现（多个）接口。
                                    如：class B extends A implements 接口A , 接口B{   }  //extends必须位于impelments之前。

                                    抽象类和接口是JAVA中实现多态的两种重要方式。 

                JAVA中的 异常
                                    异常就是在程序运行过程当中所发生的不正常的事件，异常会中断正在运行的程序。
                                    JAVA中把各种异常类封装在了一个Throwable类中。它派生出了两个子类：Error类和Exception类。
                                    Error类一般由JVM虚拟机抛出，在程序设计时更应该关注Exception类。
                                    Exception类分为两大异常：Checked异常（非运行时异常）和运行时异常。
                                    运行时异常包括：RuntimeException 及其所有子类。
                                    常见的异常有：
                                                            ArithmeticException  算术错误异常，如零作为除数。
                                                            ArrayIndexOutOfBoundsException 数组下标越界异常。
                                                            NullPointerException   空指针异常
                                                            ClassNotFoundException 不能加载所需的类异常。
                                                            InputMismatchException  数据类型不匹配异常。
                                                            IllegalArgumentException 方法接收到非法参数异常。
                                                            ClassCastException    对象强制类型转换出错异常。
                                                            NumberFormatException 数字格式化转换异常。如把“abc”转换成了数字。
            JAVA 异常处理机制
                                   JAVA的异常处理的5个 关键字： try       catch         finally          throws         throw

                                   1. try...catch结构
                                                            将有可能出现异常的代码放在try语句块中，并使用catch语句块捕获异常。
                                                             如果try遇到异常，那么try语句块中剩下的代码都将被忽略，得不到执行。
                                                            catch可以调用异常对象的方法输出异常信息，常用的方法有：
                                                            void printStackTrace()   //输出异常的堆栈信息
                                                            String getMessage()     //返回异常信息描述的字符串。
                                                            如：try{...}catch(Exception e){e.printStackTrace()}
                                   2. try..catch...finally结构
                                                            特点：无论是否发生异常，finally语句块中的代码总能被执行。
                                   3.多重catch结构   即：try{...}catch(Excepion e1){...}catch(Exception e2){...}...
                                                            特点：系统从上到下分别对每个catch块进行检测，并执行第一个与异常匹配的catch块，其后的
                                                                       catch块都将被忽略。
                                   4.throws
                                                            throws声明某个方法可能抛出的各种异常以通知调用者，throws可以同时声明多个异常，用逗号
                                                            隔开。如果调用者不知道该如何处理该异常，就可以通过throws声明异常，让上一级调用者处理
                                                            异常；最后一级为JVM来处理。 如：void divide()  throws Exception{...}
                                   5.throw
                                                           使用 throw关键字来 自行抛出异常，把问题交给调用者去处理。
                                                           如：public void setSex(String sex)  throws Exception{
                                                                            if("男".equals(sex)||"女".equals(sex))
                                                                                    this.sex = sex;
                                                                            else{
                                                                                         throw new Exception("性别必须为男或者女！");
                                                                                   } 

                                                                 }

                                 throws和 throw的 区别：
                                                          1.作用不同：throw用于程序员自行产生并抛出异常，throws用于声明该方法中抛出了异常。
                                                          2.使用的位置不同：throw位于方法体内部，可以作为单独语句使用；throws则相反。
                                                          3.内容不同：throw抛出一个 异常 对象，且只能有 一个；throws跟着 异常类，且可以有 多个。

                               除此之外，还可以 自定义异常类
                                                           步骤：1.定义异常类，并继承Exception或者RuntimeException
                                                                      2.编写异常类的构造方法，并继承父类的实现。
                                                                      3.实例化自定义异常对象，并在程序中使用throw抛出。



              面向对象编程(OOP)的原则：

                             1.摘取代码中变化的行为，形成接口。

                             2.多用组合，少用继承。

                             3.针对接口编程，不依赖于具体实现。

                            4.针对扩展开放，针对改变关闭。








                                                                                以上为本人对JAVAOOP的学习总结。
    
                                                                                                                                                    浪子回头

                                                                                                                                                    2013.08.12