Java总结5_6

2017.12.09

面向对象第一天：

目标：1.理解面向对象的变成思想；

           2.理解类与对象的关系；

           3.如何创建类与对象；

           4.方法的重载。

  一.面向对象编程（OOP）

     是一种编程思想，将对象作为解决问题的基本元素，利用对象之间的相互作用来设计程序。

   其思考问题的方式：（1）首先考虑在问题中设计到哪些对象；

                                         （2）考虑这些对象的特征和功能；

                                         （3）最后考虑对象与对象之间的关系。

二.类与对象

    1.对象的定义：描述客观事物的一个实体，由一组属性（对象具有的各种特征）和行为（对象执行的各种操作）构成。//可以看见，摸得着的具体实体

    2.类的定义：是一个模板，描述一类对象的行为和状态。//抽象的概念

   3.类与对象的关系：类是对象的类型，对象是类的实例（instance）

三.类与对象的创建

    1.定义类：

     [访问修饰符]   class   类名{

     //属性和方法的声明

     }  

    eg：public  class Person{

             String name;    //定义成员变量

             int    age;

             int    score;

            public void exam{

                System.out.println("我叫"+name+",今年"+age+"岁了，考试得了"+score+"分!");

               }

           }

      2.定义成员变量：

        [访问修饰符]     数据类型   成员变量[=初始值 ];

        成员变量作用域整个类体；成员变量数据类型科使用基本数据类型和引用数据类型；若未对成员变量进行初始化，则其使用与之对应的数据类型的默认值进行初始化。

       成员变量与局部变量的区别：前者直接在类中定义，后者定义在方法中；后者 使用前需赋值；后者作用仅限定义它的方法，该方法外无法访问。****同一方法中，不允许有同名的局部变量，不同方法中，可有；若局部变量与成员变量同名，但使用时，局部变量优先成员变量。

      3.定义类中的方法：

       [访问修饰符]     返回值类型   方法名(参数类型   参数名1,.....){

      //方法实现内容

    }

     4.对象产生和使用：

     （1）利用new关键词调用类的构造方法；

       eg:Person per=new Person();//new关键词调用Personl类的默认构造方法

            per.say();   //per对象的行为

     （2）构造方法：构造方法名字和类名相同，无返回值，不要void。

             作用：协助构造并初始化对象

             每一个类中至少包含一个构造方法；分为默认（不带参）构造方法和带参构造方法两种

            但是如果在类中没有定义构造方法，则java编译器会对提供一个默认的构造方法，此时用new调用该类的默认构造方法从而创建一个对象；若类中已经编写了一个构造方法，则java编译器不会提供默认的构造方法。

         eg：public Person(){              //不带参构造方法

                }

               

                public Person(String n,int a){         //二参构造方法

                name=n;

                age=a;

               }

                public Person(String n,int a,String s){         //三参构造方法

                name=n;

                age=a;

                sex=s;

               }

四.方法的重载：（Overloading）

    定义：同一类，同一方法名，参数列表不同（参数名称不同，参数类型不同，参数顺序不同）***方法重载与返回值、参数名称无关。

eg:public class Person{

     String name;

     int age;

    String  sex;

  //构造方法重载

    public Person(){

    }

    public Person(String name,int age){

      this.name=name;

      this.age=age;

   }

    / /方法重载

   public  void  exam(String name){

         this.name=name;

    }

    

  public  void  exam(String name,String sex){

         this.name=name;

         this.sex=sex;

     System.out.print("我叫"+name+",今年"+age+"岁了，考试得了"+score+"分！");

    }

}

    2017.12.10

学习任务：

1.this关键字；

2.static关键字；

3.封装性；

4.继承性；

5.super关键字；

6.四中访问权限；

7.方法的重写。

一.this(当前对象)

    定义：每个类的每个没有被static修饰的静态方法都会隐含一个this引用名称，它指向调用这个方法的对象（即当前对象）；在方法中使用本类的非static属性时，都会隐含使用this名称；其可看作是一个变量，其值就是当前对象的引用。

    用法：（1）类中某个非静态方法的参数名与类中某个成员变量名相同时，为了避免参数作用范围覆盖成员变量的作用范围，必须使用this关键字指向成员变量；

                （2）构造方法的第一条语句具有形式this(...)，那么这个构造方法将调用本类中的其他构造方法。

                  eg：public Person(String name,String sex ){           //两参构造

                         this.name=name;

                         this.sex=sex;

                          System.out.println("调用两参构造")

                        }

                         

                        public Person(String name,String sex ,int score){       //三参构造

                         this(name,sex); 

                         this.score=score;

                        }

二.static（属于类）

    （1） 静态成员变量：类中，用static声明的成员变量是静态成员变量，对该类的所有对象来说，static成员变量只有一份。

       eg:static int count;   静态成员属于类，对该类的所有对象是公用的

    （2）静态方法：用static声明的方法为静态方法，静态方法中只能直接调用本类的其他静态成员（变量和方法）；静态方法中不能使用this、super关键字；

     （3）静态成员可以通过类名或类的实例访问。

      （4）静态代码块：

              在类中可以使用不包含在任何方法中的静态代码块 (static block) ，当类被 JVM 载入时，静态代码块被执行， 且只被执行一次 。静态代码块经常用来初始化类的静态成员变量。

            static{

                     // 静态代码块内容

            }

三.封装性：

   定义：对外部不可见,隐藏对象的属性和实现细节；

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

   体现：a.类的封装：类的封装(属性、方法都存在于某个类中)  ；

               b.字段的封装:1字段设置为私有(private),2添加get /set 方法。

    private修饰的属性和方法只能在本类中访问。

******单例设计模式(重要)

       1.私有化构造方法,防止外部实例化该类的对象

         2. 在类的内部实例化该类的对象，

              该类的对象必须是static全局变量。

        3. 编写获取该单例对象的static方法。

         “饿汉式”单例模式:当类加载到JVM时，单例对象直接创建；

         “懒汉式”单例模式:当类加载到JVM时，并不直接创建单例对象，用户请求单例对象时(用户需要使用时)，才实例化该单例对象；

          静态方法内获取单例对象时实例化。

四.继承性：

      （1） 定义：是一个类继承另一个类。这个类拥有父类可以父类可以被继承的成员。

      子类（派生类）：实现继承

      父类（超类、基类）：被继承

      类的属性和方法可以被继承，但是私有的属性和方法不能被继承，构造方法不能被继承。

    （2）  好处：实现代码重用和扩展；模拟现实世界的关系；结构更清晰。

    （3）单继承性：Java中一个类只能有一个父类，而java.lang.object类是所有类的父类。

    （4）继承方法：

     <modifier>  class  <name>  [exrends <superclass>]{

     <declaration>*

     }

五.super关键字

   （1） super用于访问父类中定义的属性；用于调用父类中定义的成员方法；super（...）用于在子类构造方法中调用父类的构造方法。

     （2）子类构造方法中，调用父类构造方法，默认调父类无参构造，而调其他带参构造使用super(参数列表)

     （3）注意：子类和父类有同名属性时，子类中调用父类属性，使用super.属性；

                            super只能应用在成员方法和构造  方法中，不能应用在静态方法中（同this）

                             在构造方法中调构造方法必须放在第一行；

                            构造方法中this（）和super（）不能同时

六.访问权限：

    由小到大：private:只对本身类可见

                       [default]:对同一包中的类可见

                       protected:对跨包的子类和同一包中的类可见

                      public:对一切类可见

       注意：访问成员的前提是首先能访问成员所属的类

七：方法重写：

      定义：子类继承父类时，可以从父类继承它的属性和方法，如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫做方法的重写(override)

     规则：1. 只能存在于子类和父类之间；

                 2.子类的方法名称、输入参数和与父类完全一致返回值类型兼容或子类方法返回值类型是父类方法返回值类型的子类。

                 3. 权限不能比父类方法更加严格。

      注意：（1）重写的前提是先继承了父类的方法。

                  （2）在JDK1.5之后，重写方法的返回值类型可以和父类中的方法返回值类型兼容（引用类型之间）

                   （3）如果子类中成员变量、静态变量、静态方法和父类中成员变量、静态变量、静态方法相同，这种情况不是重写，可以认为是隐藏，只有非 static 成员方法之间才是重写