黑马程序员->面向对象 （1

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

 

______________________________________理解面向对象
3.1 面向对象是相对于面向过程而言。
 面相对象和面向过程都是一种思想。
 面向过程，强调的是功能行为； 面向对象，将功能封装进对象 强调具备了功能的对象。
 面向对象是基于面向过程的。  */

 面向对象：三个特征：封装，继承，多态。  （以后开发，其实就是找对象使用，没有对象，就创建一个对象。）
//                                        找对象，建立对象，使用对象，维护对象的关系。
3.1.2 类和对象的关系： 类：对现实生活中事物的描述。对象：就是类这类事物，实实在在存在的个体。

 

 名词提炼法
    描述事物其实就是在描述事物的属性和行为。
    属性对应是类中的变量，行为对应属性中的方法（函数）。

 成员变量和局部变量
      作用范围：成员变量作用于整个类中。
          局部变量作用于函数中，或者语句中。
      在内存中的位置：成员变量，在堆内存中，因为对象的村子啊，才在内存中存在。
         局部变量，存在栈内存中。//需求：描述汽车（颜色，轮胎数）。
 class  Car
 {
  String color = "红色"；//描述颜色
  int num = 4;//描述轮胎数
  void run()
  {
   System.out.println(color);//运行行为
  }
 }
 class CarDemo
 {
  public static void main(String[] args)//生产汽车，在java中通过new操作符来完成。
  {           //其实就是在堆内存中产生一个实体。
   Car c = new Car();//c就是一个类类型变量，记住：类类型变量指向对象。

   c.color = "blue";// 需求：将已有车的颜色改成blue。指挥该对象做使用，在java指挥方式是：对象.对象成员
   c.run();
  }
 }
 匿名对象。
    匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。
     如果对一个对象进行多个成员调用，必须给这个对象起个名字。//

    匿名对象使用方法二：可以将匿名对象作为实际参数进行传递。//show(new car());

3.2.........................................................................................(别看这儿→函数-类-包-框架)
   封装（encapsulation）:是指隐藏对象的属性和实现细节，仅对外提供公共方位方法。
         //   好处:将变化隔离； 便于使用； 提高重用性； 提高安全性。
       封装原则:将不需要对外提供的内容都隐藏起来； 把属性隐藏，提供公共方法对其访问。
  private ://私有，权限修饰符，用于修饰类中的成员（成员变量，成员函数）。
     //私有只在本类中有效。
  私有化以后，类以外即使建立了对象也不能直接访问。 私有仅仅是封装的一种表现形式。
  //一般用set方法和 get方法对外提供方法使其访问。
  //      之所以对外提供方法，就因为可以再访问方式中加入逻辑判断语句，
        对访问的数据进行操作，提高代码健壮性。
  public void setx();//set木有返回值类型，所以为空。
  {}
  public int getx();// get返回值类型和x相关。
  {}

3.2.1..........................构造函数
   构造函数特点：1.函数名和类名相同。2.不用定义返回值类型。3.不可以写return语句。
           作用：给对象进行初始化。 注意：1.默认构造函数特点。2.多个构造函数是以重载形式存在的。
   //对象一建立就会调用与之对应的构造函数。
   //构造函数的小细节，当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。                   
        当在类中定义了构造函数后，默认的构造函数就没有了。
 构造函数和一般函数的不同。                   //(没有构造函数的对象是不能运行的)
            写法上不同，在运行上也不同，构造函数是在对象一建立就运行，给对象初始化。
       而一般方法是对象调用才执行，就是给对对象添加对象具体的功能。
    一个对象建立，构造函数只运行一次。
    而一般方法可以被该对象调用很多次。
    //2012年5月26日0:31:29_________________________________________________
    什么时候定义构造函数？
    当分析事物时，该事物存在具备一些特性和行为，那么将这些内容定义最在构造函数中。
  //构造代码块。 作用，：给对象进行初始化。 对象一建立就运行，而且优于构造函数执行。
              和构造函数的区别：构造代码块是给所有对象进行统一初始化。而构造函数是给对应的对象初始化。
     构造代码块中定义的不同对象的共性的初始化内容。
 this 关键字。看上去为了区分成员变量和局部变量同名的情况。
     this 代表它所在的函数所属对象的引用。
         简单说，哪个对象在调用 this 所在的函数， this 就代表哪个对象。
     this //的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来代表这个对象。
      但凡本类功能内部使用了本类对象，都用 this 表示。
     this 语句：用于构造函数之间互相调用。//this 语句只能在构造函数的第一行。因为初始化动作要先执行。

3.2.2.static关键字.........................................................................
      用法：用于修饰成员（成员变量和成员函数）
       //被修饰后的成员具备以下特点：  1.随着类的加载而加载。。2.优先于对象存在。。3.被所有对象所共享。。4.可以直接被类名调用。。
                        使用注意： 1.静态方法只能访问静态成员。 2.静态方法中不可以写 this. super 关键字。 3.主函数是静态的。 

   当成员别静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。 // 用法：类名.静态成员
 class person
 {
  String name;//成员变量，实例变量。
  static String country = "cn";//静态的成员变量，类变量。
  public void show()
  {
   System.out.println(name+country);
  }
 }
 2012年5月27日22:16:04______________________________________________________
  实例变量和类变量的区别：1.。存放位置。 类变量随着类的加载而存放于方法区中。实例变量随着对象的建立而存在于堆内存中。
        2，，生命周期：类变量生命周期最长，随着类的消失而消失。实例变量生命周期随着对象的消失而消失。
  静态使用注意事项：1.。静态方法只能访问静态成员，非静态方法即可以访问静态页可以访问非静态。
        2.。静态方法中不可以定义this，super关键字。因为静态优于对象存在，所以静态方法中不可以出现this。
  静态有利有弊：利：对对象的共享数据进行单独空间的存储，节省空间，没有必要每一个对象中都存储一份。
       弊：生命周期过长，访问出现局限性。（静态虽好，只能访问静态）。

3.2.3.main主函数.........................................
  public static void main(String[] args)   主函数：是一个特殊的函数，作为程序的入口，可以被jvm调用。
  public :代表着该函数访问权限是最大的。
  static :代表主函数随着类的加载已经存在了。
  void   ：主函数没有具体的返回值。
  main   ：不是关键字，但是是一个特殊的单词，可以被jvm识别。
  （String[] args）:函数的参数，参数的类型是一个数组，该数组中的元素是字符串，字符串类型的数组。
  //什么时候使用静态？
  从两方面入手，因为静态修饰的内容有成员变量和函数。
  //什么时候定义静态变量（类变量）呢？
  当对象中出现共享数据时，该数据被静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。
 注意: //什么时候定义静态函数呢？
  当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以定义成静态的。

__________________________________________________________________________
  一个类中调用了另一个类，都在一个目录（包）中，先编译本类，则jvm会自动编译那个被调用的没有编译的类源码。
  //将方法都静态后，可以方便于使用，但是该类还是可以别其他程序建立对象。
  //为了更为严谨，强制让该类不能建立对象。
  //可以通过将构造函数是有化完成。
     注释帮助文档的制作
  //@author 后面写作者。 @version 后面版本号。 @param  后面参数
  //标完注释后，用javadoc 文档制作工具    javadoc -d XX文件名 -author -version XX要制作文档的名字。
  静态代码块     
  //格式： static { 静态代码块中的执行语句 }
  //特点： 随着类的加载而执行，只执行一次。     用于给类初始化的。
  设计模式      java中有23种设计模式。
  //解决某一类问题最行之有效的方法。
  单例设计模式
  //解决一个类在内存中只存在一个对象。
 {  想要保证对象唯一
  //1、为了避免其他对象过多建立该类对象。先禁止其他程序建立该类对象。
  //2、还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
  //3、为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
    这三步怎么用代码实现呢？
  //1、将构造函数私有化。
  //2、在类中创建一个本类对象。
  //3、提供一个方法可以获取到该对象。
 }
3.3............................................................继承
  ______________________________________________________________________________
   继承的概述： 1.提高了代码的复用性。 2. 让类与类之间产生了关系，有了这个关系，才有了多态的特性。
    // 注意：千万不要为了获取其他类的功能，简化代码而继承。
    //     必须是类与类之间有所属关系才可以继承，所属关系   is a                
    java语言中；java 只支持单继承，不支持多继承。 //因为多继承容易带来安全隐患。
            支持多重继承       //但是java保留这种机制，并用另一种形式来体现，叫多实现。
   如何使用一个继承体系中的功能呢？
    //想要使用体系，先查阅体系父类中的描述，因为父类中定义的是该体系中共性功能。
    //通过了解共性功能，就可以知道该体系的基本功能。那么这个体系已经可以基本使用了。
    在具体调用时，要创建最之类的对象，为什么？
    //一是有可能父类不能创建对象，如abstract，抽象类。
    //二是创建之类对象可以使用更多功能，包括共有的和特有的。
    简单一句话：查阅父类功能，创建子类而使用功能。
 继承： is a //
 聚集： has a // 什么里面有谁。
 聚合：  //如：球队里队员和球队的关系。
 组合：  //如：人身体，大脑和身体的关系。（不能去掉，去掉就挂了）
   1.子父类中的变量
   //如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量用this，要方位父类中的变量用super。
   //super的使用和this几乎一致，this代表的是本类对象的引用，super代表的父类对象的引用。
   2.子父类中的函数
   //当子类出现和父类一模一样的函数时，子类对象调用该函数时，会运行子类函数的内容。
   //如同父类的函数被覆盖一样，这种情况是函数的另一个特性：重写（覆盖）override。
   //当子类继承父类，沿袭了父类中的功能，到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一致。
   //这时，没有必要定义新功能，而是使用覆盖形式，保留父类的功能定义，并重写功能内容。
      2.1...重写：子类覆盖父类，必须保证子类权限大于等于父类权限，才可以重写，否则编译失败。静态只能重写静态。
       //重载：只看同名函数的参数列表。
       //重写；子父类方法要一模一样。
  3.子父类中的构造函数
   //自：子类继承父类后，创建子类对象，会默认运行子类构造函数中super（），运行一下父类的构造函数。
   //毕：在对子类对象初始化石，父类的构造函数也会运行，那是因为子类的构造寒素默认第一行有一条隐式的语句super（）；
   //  super（）：会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super（）。
     为什么子类一定要访问父类中的构造函数？自：如果父类中手动设了有参数的构造函数，那么父类中就没有了空参数的构造函数，
              那么子类也要设置带参数的super（参数），否则子类默认的空参数的super（）会因为
              找不到空参数的父类构造函数而出错。
     毕：//因为父类中的数据子类可以直接获取，所以子类对象在建立是，需要先查看父类是如何对这些数据进行初始化的，所以子类在
     // 对象初始化时，要先访问以下父类中的构造函数。如果要访问父类中指定的构造函数，可以通过手动定义super语句的方法来指定。
     //注意；super语句一定要定义在子类构造函数的第一行。
       自：如果子类构造函数第一行写了this（），那么默认的super（）就没有了，this和super只能有一个。如果在空参数子类构造
      函数中写了this（）是不行的，不可能的，（那是无限递归，要出错的）。
  子类的实例化过程   毕：/* 子类的实例化过程       结论： 子类的所有构造函数，默认都会访问父类中的空参数构造函数，因为子类每一个构造函数内的
      第一行都有一句隐式的super（）。当父类中没有空参数的构造函数时，子类必须通过手动设置super语句形式来指定要访问
      父类中的构造函数。
      当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数，子类中至少会有一个构造函数会访问父类中
        的构造函数。*/
  3.3.4.final 关键字  最终、作为一个修饰符。
       // 1，可以修饰类，函数，变量。   2. 被final 修饰的类不可以被继承。为了避免被继承，防止被子类复写功能。
    // 3，被final修饰的方法不可以被复写。 
    // 4，被final修饰的变量是一个常量，只能赋值一次，既可以修饰成员变量，也可以修饰局部变量。
   当在描述事物时，一些数据的出现是固定，不需要改变，那么这时为了增强阅读性，都给这些变量起个名字，方便
    于阅读，而这个值不需要改变，所以加上final修饰。
    作为常量：常量的书写规范所有字母都大写，如果由多个单词组成。多单词间通过_连接。
    public static final double PI = 3.14;  //全局变量，final修饰的例子。
  3.3.5.——————————抽象类——————————————————————--
   //当多个类中出现相同功能，但是功能主体不同，
   //这时可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体。
   抽象：看不懂
   抽象类的特点： 1, 抽象方法一定在抽象类中。 2 ，抽象方法和抽象类都必须被 abstract 关键字修饰。
         3, 抽象类不可以用 new 创建对象，因为调用抽象方法无意义。
         4, 抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。
        如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。
   abstract void method();//这个方法没有方法主体{}，直接加的;分号，看不懂是什么，所以加个抽象标示abstract
                        强迫子类必须要覆盖所有抽象类方法。
    //抽象类内可以定义非抽象方法，一般方法。
    抽象类和一般类没有太大的不同。
    该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。
    这些不确定的部分，也是该事物的功能，需要明确出现，但是无法定义主体。 通过抽象方法表示。
    //抽象类比一般类多了个抽象函数，就是在类中可以定义抽象方法。
    //抽象类不可以实例化。
    特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。
   3.3.6.--------------------------模板方法设计模式
   //什么是模板方法呢？
   //在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，
   //那么这时就将不确定的部分暴露出去，有该类的子类来完成。
  3.3.7............................................接口
   格式 interface {}  
   接口中的成员修饰是固定的:  System 成员常量：public static final
            System 成员函数：public abstract
   // 接口的出现将“多继承”通过另一种形式体现出来，即“多实现”
   接口：初期理解，可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以用接口的形式来表示。
   class 用于定义类
   interface 用于定义接口。
   接口定义时，格式特点：   1...接口中常见定义：常量，抽象方法。 2....接口中的成员都有固定修饰符。
     //接口中的成员都是public的
     子类实现  implements   （ 例子： class Demo implements InterfaceDemo ）
    //接口：是不可以创建对象的，因为有静态方法。需要被子类实现，子类对接口中的抽象方法全部覆盖后，子类才
   //可以实例化，否则子类是一个抽象类。
   接口是可以被多实现的，也是对多继承不支持的表现形式，叫多实现。
     class Demo implements Ifd,Ifd2,Ifd3,Ifd4  //多实现的例子
     class Demo extends Father implements InterfaceDemo2   //子类可以在继承父类的同时，实现接口。
   // 因为接口中的方法是没有方法体的抽象方法，所以在多实现的时候，如果被实现的几个接口中有相同的方法名字，
    //也可以被多实现，不会出现冲突，反正都没有方法体，不冲突。
   类-------类 ---------继承 extends
   类-------接口--------实现 implements
   接口-----接口--------继承，可以多继承 implements
     3.3.7.1...........................................................接口的特点
             接口是对外暴露的规则。  接口是程序的功能扩展。
       接口可以用来多实现。    类与接口之间是实现关系，而且类可以在继承一个类的同时实现多个接口。
       接口与接口之间可以是继承关系。
    //接口的比喻：主板上的CPU接口，内存接口，显卡接口。 同理，提高了主板支持扩展，可以安好多型号cpu，内存。
    //降低了主板和Cpu的耦合性（即紧密联系程度，如奔2的主板cpu是焊死的，耦合性超好，但不支持扩展）
   体系之外的，主体之外的，要用扩展。用一个接口写扩展功能，然后类来实现这个扩展功能。用类来写扩展并用继承
      的方法不合适，因为扩展功能不能算是一类事物，不算是类。只能算是某一类的扩展出来的小功能。

 

 

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