黑马程序员-java基础05

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

一、static静态关键字

1.static关键字：用于修饰成员（成员变量和成员函数）
2.被修饰后的成员具备以下特点：
（1）随着类的加载而加载，随的类的消失而消失
（2）优先于对象存在
（3）被所有对象所共享
（4）可以被对象调用，也可以直接被类名调用
3.使用注意
（1）静态方法只能访问静态成员，不能访问非静态成员；非静态既可以访问静态又可以访问非静态
（2）静态方法中不可以写this，super关键字
（3）主函数是静态的
4.什么时候使用静态？
（1）变量：当类中的属性的数据是所有对象都共享的，就用static修饰。
（2）方法：当方法中没有访问过非静态数据时，该方法用static修饰
5.成员变量和静态变量的区别：
（1）生命周期
成员变量又叫实例变量，是随着对象出现而出现的，随着对象的消失而消失。
静态变量又叫类变量，随着类的加载而出现，随着类的消失而消失。
（2）内存中的存储位置
成员变量存在在堆内的对象中
静态变量存储在方法的静态区中
（3）存储的数据特点
成员变量存储的数据时对象的特有数据
静态变量存储的数据是对象的共享数据
（4）调用方式
成员变量只能被对象所调用
静态变量既能被对象调用，也可以被类名调用
6.主函数
public 权限最大
static 不需要对象，直接用该类名称就可以调用该函数
void 没有具体的返回值
main 方法名称是固定的
（String[] args） 函数的参数，字符串数组类型的参数
7.设计模式：就是解决问题行之有效的方法。是一种思想
a、单例设计模式：解决问题就是保证一个类在内存中只有一个对象
（1）私有化构造函数
（2）自定义一个类对象
（3）定义一个方法返回该对象，让其他程序通过这个方法就可以获得该对象
例如：
class Single（饿汉式）
{
//1.私有化构造函数
private Single（）{}
//2.自定义类对象,为了不让对该类的成员变量进行修改所以需要加上权限private
private static Single s=new Single();
//3.定义个方法能够取到这个类的单个对象
public static Single getInstance()
{
return this.s;
}


}
 b、另一种（延迟加载模式）
例如：
class Single(懒汉式）
{
//1.私有化构造函数
private Single（）{}
//2.自定义类对象,为了不让对该类的成员变量进行修改所以需要加上权限private
private static Single s=null;
//3.定义个方法能够取到这个类的单个对象
public static Single getInstance()
{
if(s==null)
s=new Single();
return this.s;
}


}
8.静态代码块
特点：随着类的加载而执行
作用：给类初始化。
9.构造代码块：给所有对象初始化的；构造函数就是给对应的对象初始化的。 
构造函数初始化：先是调用父类构造函数
       属性显示初始化
构造函数代码块初始化
构造函数自定义内容初始化
二、继承（上）
1.好处：
（1）提高了代码的复用性。
（2）让类于类之间产生了关系，为多态特征提供了前提。
2.子类可以直接访问父类中的非私有的成员，可以间接访问私有成员（通过公共方法访问）。
3.java中继承的特点：
（1）java中只支持单继承，并不直接支持多继承。
单继承：一个子类只能有一个父类。
多继承：一个子类可以有多个父类，不直接支持，对其进行改良。
（2）继承中子父类成员中的特点：
成员变量：
成员函数：
构造函数： 
super：代表的就是父类（用法和this相似）
用法：super.父类成员。super（实际参数）
this：代表的事本类型对象的引用
super：代表的事父类的内存空间
字符类中出现同名成员变量是时用super this来区别，这种情况基本上不出现
函数的另一个特性：override overload（覆盖 复写 重写）
override（重载）：只关注本类中同名函数的参数列表，不关注返回值类型。
overload（覆盖）：子父类中一模一样的函数才会覆盖
覆盖注意事项：
（1）子类覆盖父类方法，必须保证子类方法权限大于等于父类方法权限
（2）静态只能覆盖静态，或者被静态覆盖。
三。继承(下)
1.抽象：
abstract（抽象关键字）
类是用来描述事物的 当没有足够的信息区描述一个事物时，这个描述就是抽象的
2.特点：
（1）抽象方法只有声明，没有方法体
（2）抽象方法一定定义在抽象类中，都需要被abstract关键字修饰。
（3）抽象类不可以用new创建对象。
（4）抽象类必须有自己的子类覆盖了所有的抽象方法，该子类可以被实例化。否则，盖子类还是一个抽象类。
3.问题：
（1）抽象类一定是一个父类？
是，抽象类不具体，需要子类将其具体化，并实例化。
（2）抽象类中有构造函数吗？
有，用来给子类进行对象初始化。
抽象类和一般类的区别：
相同点：都是用来描述事物的，内部都可以定义属性，行为，构造器
区别：抽象类中可以定义抽象方法，不可以实例化。因为不具体。
     一般类中不可以定义抽象方法，可以实例化。
（3）抽象类关键字不可以与哪些关键字共存？
final，是你不能有子类
abstract，是你必须有子类
private，只能在本类中
static，
（4）抽象类中是否可以不定义抽象方法？
可以的，这样做仅为不让改类实例化。
四、接口
1.如果一个抽象类的方法都是抽象类的，这时可以讲抽象类用另一种形式来体现。就是接口。
接口定义的关键字是interface
2。接口中成员的定义
常见的有两种：
（1）全局变量 public static final 数据类型 变量名 初始化值
（2）抽象方法
3.接口的好处：
是将多继承进行改良，用多实现进行体现；
一个类在继承另一个类的同时还可以实现多接口
4.接口的出现避免了单继续的局限性。（接口可以多继承）
5接口和抽象方法的异同：
共性：抽象类和接口都是不断向上抽取而来的。
区别：
（1）抽象类中可以定义抽象方法也可以定义非抽象方法，非抽象方法可以直接提供给子类使用。
    接口中只能定义抽象方法。
（2）类与类之间是继承关系，是一种关系。
    类与接口之间是实现关系，想一种关系。
（3）类与类之间只能单继承，
    而类与接口之间可以多实现。
五、多态：多种形态
1对象的多态性（类型提升，子类对象为父类型）
（提升的好处：提高了扩展性，隐藏子类型。提升的局限性：只能使用父类中的方法。如果子类有覆盖的话，运行的事子类的内容）
class 猫 extends 动物{}
class 动物{}
猫 cat=new 猫();
动物 cat=new 猫();（猫这个实例具备着两种形态，一个是猫另一个是动物。这就是多态性）
多态在程序中的体现：父类或者接口的引用指向了自己的子类对象。（父类型指向子类的对象）
2.多态的前提：
（1）必须有继承或者实现的关系
（2）通常都有覆盖的操作
3.多态的好处：提高了程序的扩展性，在思想上也有不同，以前是面对一个对象调用，对象多了调用麻烦。
              相当于指挥一批对象做事情，将复杂的事情简单化。
 多态的弊端：多态的出现，虽然可以让前期的程序使用后期的内容。
    不可以使用子类的特有内容。
注意：对于子父类类型转换动作，自始至终都是子类对象在做类型的转换而已。
4.向下转型需要注意：父类型向下转成子类型，因为子类型不唯一，所以需要进行判断。
用到的关键字是 instanceof:对象 instanceof 类型 
Animal an=new Cat();
if(an instanceof Cat)
{
Cat c=(Cat)an;
c.猫中特有的方法;
}else if(an instanceof Dog)
{
Dog d=(Dog)an;
d.狗中特有的方法;
}
5.多态中的特点：
（1）成员变量：多态调用时，对于成员变量，无论是编译还是运行，结果只参考引用型变量所属的类中的成员变量。（参考等号左边）
（2）成员函数：多态调用时，对于成员函数，编译时参考引用型变量所属类中是否有被调用的方法，有，编译通过，没有，
编译失败。运行时，参考的事对象所属的类中是否有调用的方法。（编译看左边，运行看右边）
（3）静态函数：多态调用时，编译和运行都看左边。
六、Object：所有类的超类
   所有对象都具备的方法定义在该类中