`

黑马程序员——面向对象基础

 
阅读更多

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

 

   面向对象(Object oriented ) _OO
1、面向对象的三大特点:封装、继承、多态
2、以后开发:其实就是找对象使用,没有对象就创立对象。_ _ _找对象、使用对象、维护对象
3、描述事物(类)就是描述事物的属性和行为。
4、类类型变量指向对象————Car  c = new Car()---------可以说明类为引用类型
5、成员(全局)变量:因对象的存在而存在(在堆内存中)
6、类与对象的关系:
  1. 类就是现实生活中事物的描述(属性和行为
  2. 对象就是这类事物实实在在的个体
  3. 类就是对对象个体具有的共性的描述。
6、匿名对象:只对调用方法起作用
               a--只执行一次某个类中的方法时(调用方法(方法中有内容)只调用一次,只对方法有用,对属性没有作用)可以简化
               b--作为实际参数传递
7、Encapsulated(封装)
      封装:隐藏对象的属性和完成细节,仅对外提供公共访问方式,  举例:机箱的内部构造隐藏,提供开机键对外使用。
      特点:1、将变化隔离  2、便于使用  3、提高重用性  4、提高安全性
      原则:1、将不需要对外提供的内容隐藏起来  2、把属性都隐藏,提供公共方法对其访问(一般属性)
a、函数也是一个封装体,函数说明功能是什么,不管函数内部是怎么定义的,所以函数是一个封装体(最小的)
b、类也是一个封装体,说明类中有哪些方法,有些方法隐藏起来,
                类——提供你用的是公开的,不提供你用的是私有的(往往是类中的方法调用b方法,将b方法私有)
      综上:所以不是只有private是封装体      
8、将属性私有如:age,可以防止隐患(负数)、提供的方法中进行判断
      提供公共方法访问方式原因是:访问方式中可以加入逻辑判断语句。
      封装就是对于你来说只有访问不到的,都为封装的                       
                                  构造函数:a、函数名和类名相同,b、不用定义返回值类型,c、不可以有return语句
1、对象一建立就会调用与之对应的构造函数。
2、构造函数的作用,可以给对象进行初始化的
3、当一个类中没有定义构造函数,那么系统会默认给该类加入一个空参数的构造函数
     当类中的自定义构造函数后,默认的构造函数就没有了,
4、构造函数与一般函数的区别:
    a、构造函数是在对象一建立就运行、给对象初始化。而一般方法是在对象调用才执行,是给对象添加具备的功能
    b、一个对象建立,构造函数只允许一次,二一般函数可以被对象调用多次
5、构造代码块:作用,给对象进行初始化,对象一建立就运行,而且优先于构造函数执行。
6、构造代码块与构造函数的区别:
        构造代码块是给所有的对象统一初始化,——————定义的是不同对象的共性的内容:哭
        构造函数是给对应的对象进行初始化。              
                                this关键字  
1、this代表所调函数的对象(当出现同名变量时this不能省略)----谁调用就代表谁。
2、构造函数间只能用this(name)   而且只能放在第一句
3、静态代码块在静态函数中不能用this,uper调用,只能用类.___。  (类可省略)
4、Person(String name)
{
name=name;       赋值会不成功,两个name会被认为都是局部变量中的name,故赋值不成功,所以有了this的由来。
                                              this值的就是传值的那个对象的name,(所在函数所属对象的引用)
}  
        在一个类中成员之间相互调用时对象完成的,所以在函数中除了this.name=name之外的name等都可以省略this。
5、构造函数之间调用只能用this(参数),不能用方法(参数)。而且只能放在第一句。
6、给对象初始化时:采用构造函数
7、给类初始化时:  采用静态代码块
8、javadoc -d 目录 -author -version ArrayDemo.java
    文档注释:
        这是。。。。。。
        @author  张三
        @version  v1.1
        获取。。。。
        @param arr   接受一个
        @return    会返回
 
day06
                               static关键字    
1、当用到的属性的共同数据时,采用static,减少数据占用堆内存,将数据存放到方法区中。
    String name;                                  成员变量、实例变量
    static  String country="CN";            类变量、静态的成员变量
2、当成员被修饰以后,增加了可由类名直接调用的调用方式(——类名.静态成员)    类中的方法、共同数据放在方法区(共享数据区)
3、成员变量(实例变量)、静态的成员变量(类变量)         实例随着类的消失而消失,类变量随着对象的消失而消失。
4、静态方法只能访问静态成员,非静态可以访问静态和非静态。
     静态不能为什么不能访问非静态:
       因为静态函数优先于对象存在,而非静态的随着对象的加载而加载,如属性(name)
5、静态方法不可以定义this、super关键字。
           因为静态优先于对象存在,所以静态方法不可以存在this、super。
6、什么时候定义静态函数?
        当功能内部没有访问到非静态数据(对象的特有数据)时,那么将该功能可以定义成静态的。访问到非静态数据时,不能设为静态函数
            类是public,则构造函数默认是public,构造函数随着类的变化而默认变化
7、静态代码块:  特点:随着类的加载而加载,只运行一次,用于给类初始化的。并且优先于函数执行。
      格式:static{
                静态代码块中的执行语句;
                }
8、对象的初始化过程:                显示初始化在构造代码块之前         
Person p=new Person("zhangsan",20);
/*
这句话做了些什么?
1、因为new用到了Person.class,所以会先找到Person.class文件并加载到内存中,
2、执行该类中的static代码块,如果有的话,给Person.class类进行初始化。
3、在堆内存中开辟空间,分配内存地址。
4、在堆内存中建立对象的特有属性,并进行默认初始化。
5、对属性进行显示初始化,(直接赋值的情况)
6、对对象进行构造代码块初始化
7、对对象进行相应的构造函数初始化
                8、将内存地址赋给栈内存中的变量p。
9、静态函数的利弊:
                    利:对对象的共性内容进行提取,节省内存空间(复用性提高了),可以直接通过类名调用。
                    弊:生命周期过长,访问出现局限性。
方法区存在的内容:1、类中的方法 2、类中的属性的共同数据  
                                new对象时堆内存中存放属性
 
主函数中的main不是关键字,是一个特殊的单词,能被JVM识别
    主函数是固定的,被JVM识别
 
静态代码块随着类的加载而加载,只运行一次,并优先于主函数,用于给类初始化,(很少使用,构造函数使用较多)
                           帮助文档的制作
1、定义在累上
/**
这是可以对.....操作的工具类,该类提供了.....方法。
@anthor   tang
@vesion   v1.2
*/
2、定义在函数上
/*
*获取....
@param arr接受一个int类型的
@return  会返回一个该数组中的最大值
*/
3、javadoc -d myhelp -author -version  ArrayTool.java  
继   承
1、把类中的两者的共性内容(个体的共性内容)提取出来单独封装成一个类
        如:学生和工人都有公共的name,age,将name、age单独封装成一个类,学生,工人类中写自己本身拥有的成员(属性、方法)
 
2、继承1、提高了代码复用性   2 、让类与类之间产生了关系,有了这个关系,才有了多态的产生。
 
3、注意:       千万不要为了获取其他类的功能,简化代码而继承,必须要有所属关系才能继承。
4、Java语言中,java支持单继承,不支持多继承 = 》采用了多实现的机制
      不支持的原因是:容易产生安全隐患==》当多个父类之间定义了相同的功能,但功能主体不一样,让子类不知道该运行谁,于是就产生了安全问题。
      多实现的原因:接口没有主体,即使有多个相同的功能,但是他们都没有方法,不存在不知道运行谁的情况。
5、父类私有后子类不能继承,
                  如:private  String  name等属性、方法   ,但是属性可以通过public的方法进行间接调用

6、在继承中创建一个子类对象时,分配的是两个空间
7、当子类沿袭了父类的功能时,但是内容不一样,采用复写计技术(功能名称相同,内容不同)。
 
                            1、可复写的方法有三种修饰符所修饰的 public 、protected、 default
                             2、而且子类的权限要大于等于父类的权限
 
8、复写的好处:可以很好的防止修改源码造成很多的麻烦(如功能升级)
9、子类的实例化过程:
                    在对子类对象进行初始化时,父类的构造函数也会运行,那是因为子类的所有的构造函数默认第一行都会有一个默认的隐式super()--》会访问父
           类的空参数的构造函数

        结论:子类的所有构造函数,默认第一行都会有一个默认的隐式super(),回访问父类的空参数构造函数。
                   当父类中没有空参数的构造函数时,子类必须手动通过super语句来指定要访问父类中的构造函数。
        当然,子类的构造函数第一行也可以通过手动指定this语句来访问本类中的其他构造函数,子类中至少会有一个构造函数会访问父类的构造函数

    指定this语句的那个构造函数会调用本类中的空参数构造函数,所以最终会访问到父类的构造函数,  使用this( ? )要保证本类中含有匹配的构造函数。
                                          final
1、final:可以修饰类、方法、属性-----解决安全隐患问题
         1、修饰类-----------------------最终类------------不可被继承-----------可创建对象
        2、修饰方法----------------------------------------不可被复写-----------常见常量:public  static final  数据类型   常量=常量值;
                        我们常会借助@ override.来检测是否可复写
                                                         特点:无法修改,私有的属性可以通过反射来改写
            3、属性--------------------------常量--------必须为常量赋值-------不可被改写
            4、final 修饰类类型变量(非基本数据类型)持有的引用不会变,,但地址持有的空间的内容是可变的
            5、内部类定义在类中的局部变量位置上时,只能访问该局部被 final 修饰的局部变量 -------------?
                                        抽象类
 
1、当子类出现相同功能,但是功能主体不同,还是可以向上抽取,  只抽取功能定义,而不抽取功能主体。 
2、抽象的作用强制子类去复写所有的抽象方法,建立属于自己的方法。
            我们定义一个功能时,当我们遇到不能确定功能主体的时候,这是我们就要采用抽象来解决问题。

3、抽象类: 
                   1、抽象方法一定放在抽象类中
                   2、抽象类不可创建对象,因为调用方法没有意义(没有方法主体)
                   3、抽象类的方法要想被使用,必须由子类复写所有的抽象方法后,建立子类对象调用,如果子类只覆盖不部分方法,该类还是一个抽象类。
4、获取当前本机时间:System.CurrentTimeMilis();
 
接   口
 
1、初期理解:可以认为是一个特殊的抽象类。当抽象类中的所有方法都抽象时,那么该类可以通过接口的形式来表示。
2、同过接口的形式来表示(红色部分可省略,系统自动加上)   ----------记住都是public
       常量  public static final   数据类型  p=常量值
       方法  public  abstract     数据类型 method
3、Java只支持单继承,为了解决多继承的问题,有了接口的由来。-----接口支持多继承
[ 修饰符 ] interface 接口名 [ extends ] 父接口列表{
       [ public ]  [ static ] [ finall ] 变量;
       [ public ]  [ abstract ] 方法;}
4、Java采取先继承后实现的方式  class Test  extends Demo  implements A, B{ }
5、接口是对外暴露的原则和程序的功能扩展,   降低了耦合性,主板举例
6、重写:与变量无关、与静态方法无关(叫隐藏)
7、关于静态方法,子类可以继承但是不能重写。
8、尽量千万不要不要去覆盖静态方法,虽然不会有错 --------------与马克讲的不一致。?(与7对照)
    day8                        
                             多态
1、多态可以理解为事物存在的多种形态,         
                     人  : 男人、女人
                    动物:猫、狗、猪
        1、多态的体现   2、多态的前提   3、多态的好处   4、多态的应用
2、多态的体现: Animal  c = new Cat();   1、父类的引用指向自己的子类对象   2、两则之间必须是类与类之间有关系,要么继承,要么实现
3、多态的应用:(自始自终都是子类在做着变化            
              我们可以将父类的引用强制转换成子类对象         ClassCastException : 类型转换异常
4、if ( a  instanceof   Cat )   
5、多态举例:同种类型封装成   public static void function (Animal  a )
                                                  {
                                                        a . eat() ; 
                                                        a . sleep (); 
                                                  }         
6、多态的成员特点:
                1、在编译时期:参阅引用型变量所属的类中是否有调用方法,如果有,编译通过,无编译失败。
                2、在运行时期:参阅对象所属的类中是否有调用方法
   总结:1、成员函数在多态调用时,编译看左边,运行看右边
              2、成员变量:无论编译还是运行 ,都参阅左边(引用型变量所述的类)
              3、静态成员函数:无论编译还是运行,都参照左边
7、多态的主板举例
8、多态的拓展举例

day9
                                  内部类
 
1、内部访问规则:一个类在另外一个类的内部
                        1、内部类可以直接访问外部类的中的成员、包括私有
                        2、外部类访问内部类,必须建立内部类对象
2、内部类可以被私有修饰,外部不行
3、函数可直接访问内部类中的成员:
                Outer.Inner  in = new  Outer.Inner().new  Inner();
4、当内部直接访问成员时,从内向外找,Outer。this  -》 内部直接访问外部类中的成员的原因,  this(内部方法以外的成员)
5、静态内部类
           1、 因为内部类是外部类的成员,所以内部类可以private 、static 修饰。
           2、在外部其他类中,如何直接访问static内部类的非静态成员
                            new   outer.Inner().function()。
           3、在外部其他类中,如何直接访问static内部类的静态成员
                            outer.Innner.fuction()
   注意:当内部类中定义了静态成员时,该内部类必须是静态的
             当外部类中的静态成员访问内部类时,该内部类必须是静态的
6、内部类定义的原则:当事物的内部描述事物时,该内部事物用内部类表示,如:人体。
7、匿名内部类:
             内部定义在局部时
                        1、不可以被成员修饰符修饰
                        2、可以直接访问外部类中的成员,因为持有外部类中的引用,但是不可以访问它所在的局部中的变量,只能访问被final修饰的局部变量。     
 
Object _equal:
在Java中已经提供了方法时,我们不要定自定义方法,只需覆盖(重写、复写)方法就行,(判断、类型)
Object_toString():类型@哈希值
getClass().getName()+"@" + Integer.hexString(hashCode)十六进制的
防止性别非法,设置非法判断;
        if (“男”.equals (q). “nv ”.equals( q )); 
    字符串(对象)   比较内容时,用equals 
唯一性的属性不能设置( );
静态代码块:程序运行时需要的一些数据,
1、单继承与多实现的不同原因,同名函数没有方法主体,
2、覆盖的意义:代码复用性提高
3、并不是父类的所有的成员,子类都可以继承。
        1、父类私有的成员变量与子类的无法继承 = = 》子类通过继承来的get、set间接访问完成父类的属性的和取值,
        2、父类私有的成员方法,子类无法继承,
        3、父类的构造函数子类不能被继承,但是回访问的到父类的构造函数,
        4、Public - > protected ->default- - >private
 
 
分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics