黑马程序员技术交流社区

标题: java知识 [打印本页]

---

作者: 迦南    时间: 2014-8-24 22:38
标题: java知识
final关键字：
        final表示：最终的
        1.final可以修饰类、成员变量、成员方法；
                1).被final修饰的类，表示：最终类，不能被继承
                2).被final修饰的成员变量，表示：拥有最终值，只能被赋值1次，不能被修改，
                        final的非static的变量，可以先声明后赋值，但只能在构造方法中赋值，而且只能被赋值一次；
                        final的static的变量，必须要在声明时赋值；此值在运行时不允许修改；
                3).被final修饰的成员方法，表示：最终的方法，不能被重写；

继承：
        1.为了增加代码复用，我们可以将现有的类中的属性和方法进行进一步抽取，形成一个"父类";
        2.其它类可以"继承"自这个类，使用关键字：extends.
        3.继承之后，子类将拥有可以被继承的成员变量和成员方法；
        继承的特点：
        1.java中只支持单继承，不支持多继承
        2.但是Java中允许"多级继承"
        注意：
        1.不要仅为了获取其他类中某个功能而去继承
        2.类与类之间要有所属( " is a " )关系，xx1是xx2的一种。
        类和类之间的关系：(UML)
        1.is a(是一个的关系)：继承
        2.has a(有一个的关系):
                class 学生{
                }
                class 教师{
                }
                class 班级{
                        int 楼层；//自己的属性
                        String 门牌号；//自己的属性
                        学生[] stuArray = new 学生[80];//有学员
                        教师 tea = new 教师();//有教师
                }
        3.组合关系：
                class 硬盘{
                }
                class 主板{
                }
                ....
                class 电脑{//全部都是由其它类对象组成
                        硬盘 yp = new 硬盘();
                        主板 zb = new 主板();
                        ...
                }
        4.依赖关系：
                class 学生{
                }
                class 教师{
                }
                class 校长{//校长依赖于学生类和教师类，紧"耦合"
                        void 谈话(学生 stu){
                        }
                        void 谈话(教师 tea){
                        }
                }

子类的构造过程
        1.在构造一个子类对象之前，先构造一个父类对象
        2.子类不能继承父类的private的成员属性和成员方法，在子类中可以定义和父类相同的private的成员变量
          或成员方法，但是子类自己的；
        3.父类的构造方法是不能被继承的；
        4.当继承时，一定要仔细观察父类的构造器，我们的子类构造器一定要保证能够正确的调用父类的构造器；
          当父类没有默认构造器时，子类的构造器中可以调用父类构造器，使用super()关键字；

this 和 super
        1.this 是存储本类当前对象的引用；
          super是存储父类对象的引用；
        2.当本类内部多个构造器之间，需要互相调用时，使用this()，放在第一句话
          当显示调用父类构造器时，使用super()，放在第一句话；
        3.this关键字：当"局部变量"覆盖"成员变量"时(局部变量同成员变量同名)，显示调用成员变量，使用this.XXX=
          super关键字：当"子类的成员(变量、方法)"覆盖"父类的成员"时，在子类中可以访问父类的同名成员，使用super.XXX
        4.当父类没有默认构造器时，子类的构造器中可以调用父类构造器，使用super()关键字；

方法的重写(Override)
        1.当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。
        2.重写的规则：
                子类方法的：返回值类型、方法名、参数列表：必须完全相同；
                如果只有返回值类型、方法名：编译可以通过，此方法认为是子类自己的方法
                如果只有方法名、参数列表相同，返回值不同：编译错误.不能重写，要求返回值类型必须相同；

构造方法的特点及注意事项：
   1.方法名同类名相同；
   2.没有返回值类型，甚至是void;
   3.不能返回任何值；
   4.构造方法可以重载；
   5.构造方法可以接收参数；
   6.构造方法是自动执行，当实例化一个此类对象的时候；
   7.实例化一个对象的时候，只能执行一个构造方法；
   8.构造方法可以调用构造方法，使用this([参数]);
   9.构造方法可以被修饰为private(私有的)；

   注意：
   1.如果我们不指定构造方法的话，系统会自动为我们的类添加一个默认构造方法：无参、不做任何事情；
     如果我们指定了构造方法，那么系统将不再自动添加默认构造方法；


抽象类：       
        当一个方法不需要定义方法体，可以只有方法声明，此时，这个方法就是一个抽象方法，
        抽象方法，使用关键字：使用abstract关键字修饰；
        一个类中如果有一个抽象方法，那么这个类必须也被声明为abstract(抽象类)
        一个类成为抽象类后，意味着：此类不能被实例化；就是用来被继承的；
        如果一个子类继承一个抽象类后，必须要重写父类的抽象方法。否则，子类也必须是抽象的；
        子类继承抽象类使用extends关键字，同样只能单继承；一个抽象类可以继承另一个抽象类
        1.抽象类中可以有抽象方法，可以有普通方法；也可以有普通的成员变量
        2.抽象类中可以不包含抽象方法；也可以什么都不包含；
        3.抽象类中有构造方法么？
                可以的。虽然抽象类不能被实例化，但抽象类可以包含构造方法，用来子类给
                成员变量赋值；
        4.抽象关键字abstract不可以和哪些关键字共存？
                1).private :因为一个abstract方法需要被重写，所以不能修饰为private;
                2).final:因为一个abstract方法需要被重写。被final修饰的方法是不能被重写的，所以不能同final共存；
                3).static:因为一个abstract方法没有方法体。静态方法需要对方法体执行内容分配空间，所以不能同static共存；
        5.抽象类中可不可以没有抽象方法？
                抽象类中可以什么都没有！！！
模板模式：
        1.抽象类作为一个模板类；
        2.抽象类中要包含模板方法和基本方法；
        3.模板方法要调用基本方法；
        4.基本方法是抽象的，需要子类去实现；


单例模式：

        在整个引用程序运行周期，对于某个类的对象，只需要一个对象存在，
        此时可以将此类设为"单例模式"；

        制作单例模式：

        1.将默认构造器私有化，外界不能实例化此类对象；
        2.声明一个私有的，静态的此类对象的引用，作为成员变量；
        3.声明一个公有的，静态的获取此类对象的方法；
                注意：单例，在此方法内控制；


多态：某一类事物的多种存在形态；

        1.一个父类的引用指向子类对象
多态的特点：

        1.当父类的引用指向子类对象时，访问被覆盖成员时，访问的是父类的；
          在调用被覆盖的方法时，调用的是"子类的"。方法是运行时动态绑定的；

        2.当父类的引用指向子类对象时，不能访问子类自有的成员；只能访问被覆盖的；
//类型自动向上转型：子类类型——>父类类型(自动转)
如果明确接收的子类类型，可以将父类变量强制转换为子类类型：向下转型：父类——>子类(强制转)
Student stu = (Student)obj;//传入的是Student类型OK的。如果传入的是Teacher类型： java.lang.ClassCastException（运行时）
                //可以使用instanceof关键字进行判断
                //双目运算符：判断左边的变量是否是右边的"类"类型。返回一个boolean值
Personnel p = new Teacher();//向上转型(自动)
                Teacher t = (Teacher)p;//向下转型(强制)
多态的应用：

        1.增加一个父类，让所有的人员继承自这个父类
        2.修改Master类，保留一个talk方法，接收参数改为：父类类型；
        3.一旦增加新人员时，只需继承自Personnel类，重写方法，Master类不需要修改；

接口：

        当我们抽取出抽象方法后，如果全部都是抽象方法，可以将此类定义为"接口"
        1.定义接口：使用关键字interface。没有class关键字
        2.接口同抽象类，都不能被实例化，使用来被继承的；
        3.一个类如果需要继承一个接口使用关键字：implements(实现)
        4.一个类如果实现一个接口，必须重写接口中定义的抽象方法,访问修饰符一定要等于或大于父类的访问修饰符；如果不全部实现，这个类就是一个抽象类；
        5.接口中可以定义成员变量、抽象方法：
          1).接口中定义的成员变量必须被声明为：public static final
             上述关键字可以不写，系统会自动添加；
          2).接口中定义的成员方法，必须被声明为:public abstract
                 上述关键字可以不写，系统会自动添加；


接口和抽象类：

相同点：
1.都不能被实例化，都是用来被继承的；

不同点：
1.抽象类：抽象类中可以有实现的方法和抽象的方法；
  接口：  接口中只能包含抽象方法；
2.抽象类：抽象类使用关键字abstract class定义
  接口：  接口使用关键字interface 定义
3.抽象类：子类继承抽象类使用关键字：extends，只能单继承
  接口：  实现类实现接口使用关键字：implements，可以多实现；
4.抽象类：成员变量可以是普通的成员变量；
  接口：  成员变量必须被修饰为：public static final
5.抽象类：抽象类中可以有构造方法；
  接口：  没有构造器；

---

作者: 忆梦追风    时间: 2014-8-24 22:39
感谢分享，楼主继续啊

---

作者: liqiaohui    时间: 2014-8-24 23:26
总结的很详细  

---

作者: 迦南    时间: 2014-8-24 23:46

liqiaohui 发表于 2014-8-24 23:26
总结的很详细

嗯，谢谢

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2