学习java第四周总结。。。

本周学习了构造方法、方法重载、封装性、访问权限修饰符、子类、方法重写、多态

http://t.csdn.cn/MyDjFhttp://t.csdn.cn/MyDjF

构造方法

什么是构造方法

1.构造方法就是类构造对象是调用的方法，对于对象的初始化工作
2.构造方法是实例化一个类的对象，也就是new的时候，最先调用的方法                                          (用来创建对象及对象的初始化)

构造方法的定义

  构造方法是在类中定义的，构造方法的定义格式：方法名与类名称相同，无返回值类型的声明
  对象的实例化语句：Dog dog=new Dog();//new dog后面有一个括号，带括号表示调用方法，此时调用的方法是构造方法

访问权限修饰符   构造方法名（）{
        //初始化代码
}

不写构造方法，系统会提供默认的无参构造方法

写了构造方法，就会替换掉默认的无参构造方法

自定义构造方法  方法名相同，参数不同，返回值不同

构造方法之间的相互调用

可以使用this关键字调用构造方法

注意：在构造方法相互调用的时候必须要有出口

方法重载

在同一个类中，出现多个方法的方法名相同，参数列表不同（参数的个数、参数的类型、参数顺序）的现象

1. 在同一个类中
2. 方法名相同
3. 参数列表不同
4. 与返回值类型、访问权限修饰符无关

this关键字

调用类中的属性 
调用类中的方法或构造方法 
表示当前对象：在方法被调用的过程中，哪个对象调用了方法，在方法内的this就表示谁
可以通过类名.this来表示谁的对象

局部变量和成员变量

变量作用域

变量按照其所在的位置，可以分为成员变量(全局变量)、局部变量两大类

成员变量(全局变量)

作用类在其他结构外的变量
成员变量的作用范围是整个类中都可以使用（在静态方法中不能使用非静态的成员变量，可以式样静态的成员变量）
成员变量系统会给它赋值一个默认值
在同一个类中，不能有同名的全局变量，全局变量和局部变量可以同名，在使用的时候局部变量具有更高的优先级

局部变量

作用方法或者其他结构内的变量
局部变量的作用范围只限于定义局部变量的结构中
局部变量没有默认值，在使用之前要进行赋值，否则会报错
在不同的方法内（获取其他结构内）可以有相同名称的局部变量，在同一个方法或者结构内不能有同名的局部变量

局部变量名称可以和成员变量一样，在方法中使用的时候，就是采用就近原则

局部变量与成员变量的区别

1.在类中的位置不同
        成员变量:在类中定义
        局部变量:在方法中定义或者方法的参数
2.在内存中的位置不同
        成员变量:在堆内存中(成员变量属于对象，对象进堆内存)
        局部变量:在栈内存中(局部变量属于方法，方法进栈内存)
3.生命周期不同
        成员变量:随着对象的创建而存在，随着对象的销毁而消失
        局部变量:随着方法的调用而存在，随着方法调用的完毕而消失
4.初始化值不同
        成员变量:有默认初始化值，引用类型默认为null
        局部变量:没有默认初始化变量，必须定义，赋值，然后才能使用

构造方法小结

1.构造方法的名称与类名相同，没有返回值声明（包括void）
2.构造方法用于初始化数据（属性）
3.每一个类中都会有一个默认的无参构造方法
4.如果类中有显示的构造方法，那么默认的构造方法将无效
5.如果有显式的构造方法，还想保留默认构造方法要显式的写出来
6.构造方法可以有多个，但参数不一样，成为构造方法的重载
7.在构造方法中调用另一个构造方法，使用this(…),该句代码必须在第一句。
8.构造方法之间的调用，必须要有出口
9.给对象初始化数据可以使用构造方法或setter方法，通常情况下，两者都会保留
10.一个好的编程习惯是要保留默认的构造方法。（为了方便一些框架代码使用反射来创建对象）
11.private Dog(){}，构造方法私有化，当我们的需求时为了保证该类只有一个对象时，就会使用构造方方法私有化。什么时候一个类只需要一个对象？比如，工具类(没有属性的类，只有行为)并且该工具对象被频繁使用。权衡只用一个对象与产生多个对象的内存使用，来确定该类是否定义为只需要一个对象

---

http://t.csdn.cn/qBZ4Khttp://t.csdn.cn/qBZ4K 

封装性

创建的对象可以直接通过对象名，属性名去赋值，从而造成了在赋值的时候能够轻易的赋予一个不合理的值。 能不能使用一种方式，让对象不能直接去通过对象名.属性名赋值，而是间接的去给属性赋值，可以使用封装来实现这一个需求

封装的概念

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

封装的原则

将不需要对外提供的内容都隐藏起来
把属性隐藏，提供公共方法对其访问。

封装有：
    属性的封装、方法的封装、类的封装、组件的封装、模块化的封装、系统级封装

如何实现封装

（1）.修改属性可见性:设为private，防止错误的修改
（2）.创建公有的getter/setter方法:用于属性的读写
（3）.在getter/setter方法中加入属性控制语句:对属性值的合法性进行判断

封装的好处

便于使用者正确使用系统，防止错误修改属性
有助于系统之间的松耦合，提高系统独立性
提高软件的可重用性
降低了构建大型系统的风险

封装的缺点

会影响执行效率

封装性总结

如果属性没有封装，那么在本类之外创建对象后，可以直接访问属性private关键字：访问权限修饰符;private表示私有的，私有的属性或方法只能在本类中访问共有的属性和方法可以被类外部的其他类访问。想要在类外部访问私有属性，我们需要提供拥有的方法来间接访问通常在一个类中属性都私有化，并对外提供getter and setter方法

包

1.为什么需要包

文档分门别类，易于查找和管理
使用目录解决文件同名冲突问题

2.包的作用

允许类组成较小的单元（类似文件夹），易于找到和使用相应的文件
防止命名冲突区分名字相同的类
有助于实施访问权限控制

3.如何创建包

package cn.jbit.inherit;   //声明包
        作为Java源代码第一条语句 
        用package声明包，以分号结尾

4.包命名规范

包名由小写字母组成，不能以圆点开头或结尾     package mypackage;
包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名 package net.javagroup.mypackage;包名后续部分依不同机构内部的规范不同而不同   package net.javagroup.research.powerproject;

5.用MyEclipse创建包

JDK提供基本包
        java.lang：虚拟机自动引入
        java.util：提供一些实用类
        java.io:输入、输出
使用MyEclipse创建包的两种方法
        分别创建包和类
        创建类的过程中创建类所在的包

6.如何导入包

为了使用不在同一包中的类，需要在Java程序中使用import关键字导入这个类
        import   包名. 类名；
        import java.util.*;      //导入java.util包中所有类
        import cn.jtest.classandobject.School;    //导入指定包中指定类
1. 系统包：java.util
2. 自定义包：cn.jtest.classandobject
*： 指包中的所有类
School ：指包中的School类

7.使用包的注意事项

一个类同时引用了两个来自不同包的同名类
        必须通过完整类名来区分
每个包都是独立的，顶层包不会包含子包的类
package和import的顺序是固定的
        package必须位于第一行（忽略注释行）
        只允许有一个package语句
        其次是import
        接着是类的声明

访问权限修饰符

类的访问控制

    public修饰符：公有访问级别
    默认修饰符：包级私有访问级别

	同一个类中	同一个包中	同一个包的子类中	任何地方	不同的包中	不同包的子类中
private	可以	不可以	不可以	不可以	不可以	不可以
默认修饰符	可以	可以	可以	不可以	不可以	不可以
protected	可以	可以	可以	不可以	不可以	可以
public	可以	可以	可以	可以	可以	可以

static修饰符

static可以用来修饰
成员变量 静态变量，可以直接通过类名访问           
 类的成员变量包括

        类变量（静态变量）

                被static修饰的变量
                在内存中只有一个拷贝
                类内部，可在任何方法内直接访问静态变量
                其他类中，可以直接通过类名访问

        实例变量
                没有被static修饰的变量
                每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响

成员方法  静态方法，可以直接通过类名访问
代码块  静态代码块，当Java虚拟机加载类时，就会执行该代码块

static变量的作用

（1）能被类的所有实例共享，可作为实例之间进行交流的共享数据
（2）如果类的所有实例都包含一个相同的常量属性，可把这个属性定义为静态常量类型，从而节省内存空间

---

http://t.csdn.cn/XQGivhttp://t.csdn.cn/XQGiv子类

静态方法

在静态方法中不能使用this和super关键字，因为static是属于类的，不是属于某一个对象
            在静态方法中可以直接调用本类中其他的静态方法
            在静态方法中不能直接调用本类中其他的非静态方法
            在静态方法中可以直接访问本类中其他的静态变量
            在静态方法中不能直接访问本类中其他的非静态变量
            在非静态方法中可以直接调用本例中的其他静态方法
            在非静态方法中可以直接方法问本类中其他的静态变量
            在非静态方法中可以直接方法问本类中其他的非静态变量
            在非静态方法中可以直接调用本类中的其它非静态方法

静态的只能访问静态的（变量、方法） 非静态的既可以访问静态的也可以访问非静态的

继承

继承的好处：

方便修改代码
减少代码量

继承是Java中实现代码重用的重要手段之一。Java中只支持单根继承，即一个类只能有一个直接父类

子类访问父类成员

访问父类构造方法
    super();    
    super(name);
 访问父类属性
    super.name;
 访问父类方法
    super.print();

super关键字来访问父类的成员

    （1）使用super关键字,super代表父类对象 
    （2）在子类构造方法中调用且必须是第一句
    （3）不可以访问父类中定义为private的属性和方法

继承条件下的构造方法

        继承条件下构造方法的调用规则
        子类构造方法没有通过super显式调用父类的有参构造方法，也没通过this显式调用自身其他构造方法------系统默认调用父类的无参构造方法
        子类构造方法通过super显式调用父类的有参构造方法------执行父类相应构造方法，而不执行父类无参构造方法
        子类构造方法通过this显式调用自身的其他构造方法，在相应构造方法中应用以上两条规则

子类继承父类的什么？

        继承public和protected修饰的属性和方法，不管子类和父类是否在同一个包里
        继承默认权限修饰符修饰的属性和方法，但子类和父类必须在同一个包里

不能被继承的父类成员

        private成员 
        子类与父类不在同包,使用默认访问权限的成员
        构造方法

何时使用继承？

        继承与真实世界类似
        继承是代码重用的一种方式

---

http://t.csdn.cn/Dj78ghttp://t.csdn.cn/Dj78g方法重写

为什么要使用方法重写

父类的方法无法满足子类的需求，就需要使用到方法重写

什么是方法重写

子类根据需求对从父类继承的方法进行重新编写
重写时，可以用super.方法的方式来保留父类的方法
构造方法不能被重写

方法重写的规则

需要是该类的子类
方法名相同
参数列表相同
返回值类型相同或者是其子类
访问权限不能严于父类

方法重写与方法重载

	位置	方法名	参数表	返回值	访问权限修饰符
方法重写	子类	相同	相同	相同或者是子类	不能比父类更严格
方法重载	同类	相同	不同	无关	无关

Object类

Object类是所有类的父类

Object被子类经常重写的方法

toString()    返回当前对象本身的有关信息
equals()    比较两个对象是否是同一个对象，是则返回true
hashCode()    返回改对象的哈希代码值
getClass()    获取当前对象所属的类信息，返回Class对象

toString对象的重写

若不重写toString，输出的则是：包名.类名.@.hash码值，是地址；若重写之后则输出对象本身的值。

equals()方法

为什么要重写equals()方法：

 object类中的equals()方法比较是的两个对象的地址值，不能满足子类的需求

   “==”表示比较两个基本数据类型，“equals”表示比较两个对象。若不引入object类的equals方法，则输出为对象的地址，而引入以后则输出对象的值。

---

http://t.csdn.cn/t40jchttp://t.csdn.cn/t40jc

多态

为什么使用多态

如果子类中需要添加什么方法需要频繁修改代码，代码可扩展性、可维护性差。

什么是多态

同一个事物，作用条件不一样，结果不一样。同一个父类引用，指向不同的子类实例，执行不同的操作。方法重写是实现多态的前提

多态实现步骤

1）在抽象父类中定义抽象方法
2）子类继承抽象父类并重写父类中所有的抽象方法
3）测试类中创建父类引用指向不同的子类实例，父类引用调用方法，调用的是子类重写后的那些方法

类型转换

向上转型：父类的引用指向子类的实例

类名 对象名 = new 子类类名();
   如： Pet pet1 = new Cat("喵喵", 45, 100, "绿色");
           master.cure(pet1);
此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法
此时通过父类引用变量无法调用子类特有的方法

关于引用的问题
父类的引用指向子类的实例，通过父类的引用去调用方法的时候，如果重写了父类引用调用的哪个方法，那么父类引用调用的是子类重写后的那个方法，如果父类引用调用的那个方法在子类中没有被重写，那么父类引用调用的就是父类里的那个方法

除了向上转型还有

向下转型

向上转型就相当于自动类型转换

向下转型就相当于强制类型转换

向下转型，子类的引用指向父类的引用

<子类型> <引用变量名> = (<子类型> )<父类型的引用变量>;
    Son1 son = (Son1) father;
    son.sonMethod();
    在向下转型的时候，容易出现ClassCastException（类型转换异常），原因是将父类引用转换成了不匹配的子类对象

instanceof

        if (father instanceof Son1) {
			Son1 son = (Son1) father;
			son.sonMethod();
		} else if (father instanceof Son2) {
			Son2 son = (Son2) father;
			son.son2Method();
		}

抽象方法

使用abstrcat修饰方法位抽象方法
    1）抽象方法没有方法体
    2）抽象方法所在的类需要声明为抽象类
    3）子类继承一个抽象类后，子类必须重写抽象父类中所有的抽象类方法，如果不重写，那么子类也需要定义为抽象类
抽象类：使用abstract修饰的类为抽象类
    1）抽象类的声明跟之前声明一个类没有太大的区别，依然可以封装属性、声明构造方法、声明getXXX()/setXXX()方法、重写toString()方法等
    2）抽象类中可以包含抽象方法、也可以不包含抽象方法（但是抽象方法所在的类一定要声明为抽象类）
    3）抽象类不能实例化（不能通过new的方式来创建对象）