黑马程序员-阶段小结二

------- android培训、java培训、期待与您交流！ ----------

【六】

 一.面向对象的概念：

    1).面向对象是相对于面向过程而言；

    2).面向对象分析(OOA)

       面向对象设计(OOD)

       面向对象编程(OOP)

    3).面向对象的特点：

       A.封装：将成员属性私有化，有选择的对外提供公有的方法；

       B.继承：将一些类的共有的部分抽取出来，形成一个父类，其它类可以继承自这个类；

       达到代码复用的目的；另外也为多态提供前提；

       C.多态：用父类的引用指向子类的对象。有利于程序的扩展；

    4).类和对象的关系：

       A.类：就是对一些事物的定义；它在我们的代码中反映为一个class；它定义了具有相同特征的一些

         事物的属性和行为；它类似于我们现实中的表格；设计图纸；

       B.对象：就是具体存在事物。它在我们的代码中表示为通过new关键字，在内存中会产生堆空间，具有自己

         特有的属性值；

       C.类和对象的关系：一个类可以产生多个对象；类：就是一个对事物的描述性的定义；

                                                对象：就是具体的事物；

    5).定义类使用class关键字：

       类中可以包含：

         成员属性；

与"局部变量不同"：

A.局部基本类型变量：

  a).声明后必须初始化，才能被访问；

  b).存储在栈中

  c).所在的代码块结束，立即从栈中消除；

B.成员变量：

  a).声明后，系统会自动初始化，赋默认值：整数：0，小数：0.0，布尔：false，字符：'\u0000'，其它引用类型：null

  b).存储在堆中；

  c).所在的代码块结束，栈中的引用会立即消除，但堆中的数据不会立即消失，会成为垃圾，后期由JVM中的垃圾回收器自动回收。

 成员方法；

 类；

 接口；

    6).匿名对象：

       1.如果我们不需要对象的名字，可以使用匿名对象：

         new MyTools().getMax(10,20);

       2.当我们调用函数，而函数的形参需要某个引用类，而这个引用我们不需要，此时，可以传一个匿名对象：

         fun(new Student());

    7).封装：

       将成员变量私有化，对外提供公有的方法；

       1.私有：private

       2.公有：public

    8).this关键字：

       1.对于一个类的多个对象，每个对象会有一份"成员变量"的副本，但对于方法体，所有对象共享一个方法体；

         所以一个方法是被多个对象共享的。此时，当运行这个方法时，Java会自动将这个方法绑定到当前运行的

 对象上，隐式的使用this。

       2.this存储当前对象的引用；

       3.同过this可以访问成员变量、成员方法、构造方法；

【七】

一.初始化数据成员：

   1).初始化代码块：是位于类体中的一对大括号{}内的代码块。每次构造一个此类对象时，会执行一次。

                    它比构造函数先期执行；用于初始化成员变量；

           2).构造函数：

      A.构造函数的名字跟类名相同；

      B.构造函数不能声明返回值类型，即使是void；

      C.构造函数是在实例化对象时被自动调用，只被调用一次；

      D.一个类可以有多个构造函数(构造函数的重载)；

      E.如果我们的类不写构造函数，系统会自动添加一个默认构造函数(无参，无方法体，什么都不做的)；

        如果我们定义了构造函数，系统将不会给我添加默认构造函数；

      F.构造函数不能return一个具体值，但可以写return;语句；表示结束方法执行；

      G.构造函数之间可以互相调用，使用this()或者带参数this(实参)；

      H.构造函数的访问修饰符可以是private;意味着外部不能实例化一个此类对象。(单例模式)

   3).静态初始化代码块：

      A.普通代码块之前加static关键字：static{}；

      B.第一次实例化此类对象时，只执行一次；

      C.执行顺序：静态初始化代码块、初始化代码块、构造函数

      D.静态初始化代码块如果访问数据成员，那么数据成员一定要是静态；

二.static关键字：

   1).修饰类的成员；

   2).静态成员会在没有类的对象产生前，先期被加载，并分配空间；

   3).静态成员可以通过类名调用，可以通过对象名调用；

   4).静态的成员变量，存储在方法区的"静态区"，对多个对象是共享的；

   5).静态方法只能访问静态成员；

   6).静态方法中不能使用this,super关键字；

   7).main方法是静态的；

三.main方法：

   A.格式：public static void main(String[] args)

   B.public :公有的；

   C.static :静态的，不需要类的实例就可以被访问；

   D.void : 不返回值；

   E.main : main不是关键字。它是一个约定的名称，必须要main，由虚拟机自动寻找并加载运行；

   F.String[] args : 用于从控制台接受参数；

四.制作帮助文档：

   A.使用javadoc.exe，在JDK安装目录/bin/，同java.exe和javac.exe在相同目录下；

   B.源码中需要使用"文档注释"：以：/**开头，以*/结束；

五.生成随机数：

   A.java.lang.Math类中的random。random()是一个静态的方法，直接使用类名就可以调用；

   B.每次生成一个大于或等于0.0，小于1.0的一个浮点数；

   C.生成1——10的数字：(int)(Math.random() * 10) + 1;

【八】

一.继承：

   1.多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，

     只要继承那个类即可。达到一个代码复用的目的；

   2.使用关键字extends；

   3.Java只支持"单继承"，不允许同时继承自多个类。但允许"多层继承"；

   4.当实例化一个子类的时候，会同时实例化它的父类；

   5.父类中私有的成员是不会被继承的；

   6.注意：父类的构造函数。如果父类定义了构造函数，系统将不会为父类添加默认构造函数。此时在实例化

     子类对象时要注意，子类的构造一定满足构造父类的条件；

     显示调用父类构造函数使用：super()或super(实参);

     调用语句一定写在第一句话；

   7.super关键字：

     A.指向父类；

     B.调用父类的成员变量、成员方法、构造函数；

二.函数重写(Override)

   1.子类可以定义同父类返回值类型、方法名、参数列表全部相同，并具有与父类方法相同或更宽的访问修饰符的方法。

     这个方法就是重写父类的方法；

   2.重写：

     A.方法名、参数列表相同，但返回值类型不同：编译错误；

     B.返回值类型、方法名相同，但参数列表不同：通过编译，认为是子类自有的方法；

   3.重写与重载：

     A.重写：指在子、父类之间，子类定义了同父类一模一样的方法，这时叫：子类重写了父类的方法；

     B.重载：指在一个类中。定义多个同名，但参数列表不同的方法。跟返回值类型无关；跟形参名无关

三.final关键字：

   1.可以修饰类、成员变量、成员方法；

     A.当一个类被修饰为final：此类是最终类，不能被继承；

     B.当一个成员变量被修饰为final:此变量拥有最终的值，不能被更改；

     C.当一个方法被修饰为final:此方法是最终方法，不能被重写；

     D.一个局部内部类如果要访问一个局部变量，那么要求这个变量必须是final;

interface IA{

void print();

}

       class A{

public IA show(){

final int num = 10;

class B implements IA{

public void print(){

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

}

}

B b = new B();

return b;

}

       }

 四.多态：

    1.一个父类(父抽象类、父接口)类型的引用，指向子类的对象，叫：多态；

    2.多态的情况下，访问的成员，父类(父抽象类、父接口)中一定要存在，否则不能通过编译；

      在运行时：对于被覆盖的成员变量，访问的是父类的；

                对于重写的方法，访问的是子类的；(方法是在运行时动态绑定的)

    3.当父类的引用指向子类对象时，类型会自动向上转型：Person p = new Student();

      也可以将父类类型，强制转换为它所指向的子类对象的类型:Student stu = (Student)p;

      使用关键字：instanceof来判断一个引用类型是否是某个类类型：if(p instanceof Student){}

【九】

一.抽象类：

   1.使用abstract修饰；

   2.抽象方法不能有方法体；

   3.如果一个类中包含抽象方法，那么这个类必须是抽象的。

   4.一个抽象类可以没有抽象方法；

   5.抽象类中可以包含普通成员变量、成员方法、抽象方法；

   6.一个抽象类不能被实例化，用类被继承；

   7.子类继承一个抽象类，必须全部重写抽象类中的抽象方法，否则，就也得是一个抽象类；

   8.子类继承抽象类使用关键字：extends，仍然是单继承；

   9.抽象类中可以包含构造函数；

   10.abstract关键字不能跟哪些关键字同时使用？

      A.final

      B.static

      C.private

二.接口：

   1.可以定义成员变量、抽象方法；

   2.接口中的成员变量被自动修饰为：public static final

   3.接口中的抽象方法被自动修饰为：public abstract

   4.使用接口可以用于功能扩展。

   5.一个类只能同时继承自一个类/抽象类，但可以同时实现多个接口。

   6.接口和接口之间，是继承关系，使用关键字：extends，而且可以多继承；

   7.一个类实现接口后，必须实现接口中所有的抽象方法；

   8.接口同抽象类一样，不能被实例化，是需要子类实现；定义接口关键字：interface。

     实现接口使用关键字：implements

【十】

一.内部类：

   1.在一个类的内部可以定义一个类，这个内部的类就叫做：内部类；

   2.实例化一个普通内部类对象之前，要先实例化它的外部类对象；

   3.内部类的成员方法可以访问外部类的成员；

   4.内部类的成员也可以覆盖外部类成员；

二.局部内部类：

   1.可以将类定义在一个方法体内，这样的类叫：局部内部类；

   2.可以在外部通过父接口或父类的形式获取局部内部类的对象；

   3.局部内部类如果访问局部变量，要求此变量必须是final;

三.匿名局部内部类：

   1.在方法内可以定义没有名字的内部类；

四.包：

   1.可以将我们的类进行分类管理，使用包。关键字：package；

   2.定义包语句放在源文件的第一句话；

   3.使用其它包下的类：

     A.使用全名限定的类名：com.itcast.tools.MyTools mt = new com.itcast.tools.MyTools();

     B.使用导入包语句：import com.itcast.tools.MyTools;

   4.导入包语句可以有多条，可以使用通配符：import com.itcast.tools.*;

     通配符只统配tools下的所有类，如果tools下有子包，不包括这些子包下的其它类；

   5.如果要package和import 要先package后import；

五.访问修饰符：

   1.public、protected、(默认)、private；

   2.对于顶层类，只用public 和(默认)；

   3.public : 修饰类、成员，说明整个工程内的其它类都可以访问；

     protected:修饰成员，只能被同一个包下的其它类访问；如果在包外，只能被子类访问；

     (默认)：修饰类、成员，只能被同一个包下的其它类访问；

     private：修饰成员。只能在类内访问；

六.制作Jar包：

   1.使用jar.exe;

   2.命令：\>jar -cvf mypack.jar com

   3.jar包就是一个压缩包，是一组class的集合。可以方便的被其它工程下的类使用