黑马程序员——面向对象

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

对象和类

什么是对象，什么是类。

类是对象的抽象，而对象是类的具体实例。

我们能够看到的事物具有相关的特性(状态)和行为属性他就是对象。“世间万物皆是对象”

人，鱼，走兽，飞鸟，月亮，空气 

用类可以创建和实例化带有具体属性的对象

实例是指每一个特性和属性都有的具体值的对象（特定类型的状态）

类是用来创建对象的模型。

class Dog {

int size;//大小——实例变量

String breed;//品种

String name;//名字

void bark(){//方法

System.out.println("汪汪叫!");

}

}

包

package：java包的命名规则全部使用小写 e.g. package person//指定类的包名

导入包：import

控制访问

可供访问的对象publicprotectedpackageprivate定义类是是是是相同包中的类是是是否不同包中的子类是是否否不同包中的非子类是否否否

public class Person{ //此类是public类型

private  String  name;//private类型其他包不可以看到

protected int age//可以被子类看到

}

构造方法

默认的构造方法 pubic Person(){ }

构造方法是当用类生成对象时，系统在生成对象的过程中利用的方法。

构造方法在生成对象的时候会被调用，但并不是构造方法生成了对象。

构造方法的方法名与类名相同。

构造方法是在对象生成的过程中自动调用，不可能利用指令去调用。

在一个对象的生成周期中构造方法只用一次，一旦这个对象生成，那么这个构造方法失效。

Person p=new Person();是调用了默认的构造方法，使用构造方法时，java自动创建拥有该类的全部属性的新对象。

public Person (String name,int age){}//有参数的构造方法

重载（overloading）

Overloading：在一个类中可以定义多个同名方法，各个方法的参数一定不同。但修饰词可能相同，返回值也可能相同。

类成员的修饰符

this

this表示当前对象。

final修饰符(可以修饰类，函数，变量)

被他修饰的类不可以继承，避免了子类复写功能。（断子绝孙）

被他修饰的方法不可以被重写。

static

单例模式

 确保某个类只有一个实例，并且为该类提供一个全局的访问点。

第一种方式

public class Singleton {

private static Singleton instance = new HungrySingleton();

private Singleton() {

}
public static Singleton getInstance() {
return instance;

}
}

第二种方式

 public class Singleton {

private static Singleton instance = null;//建立静态私有化变量

private Singleton() {
// do something
}

public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}

}

类的继承

继承是在已有的基础上定义一个新类。这个新类继承了已有类（父类）的所有特性和行为。子类同时还通过引入自己的新特性和行为，来扩展父类。

继承通常用来从上到下的方式组织抽象，反映从最普通到最特殊情况。

乐器可分为五类：体鸣乐器、膜鸣乐器、气鸣乐器、弦鸣乐器和电鸣乐器。

其中气鸣乐器又可以分为：

（1）唇振气鸣乐器,(2)嗓振气鸣乐器,（3）边棱气鸣乐器,（4）吹口气鸣乐器,（5）单簧气鸣乐器,（6）双簧气鸣乐器,（7）自由簧气鸣乐器。7个子类

（3）边棱气鸣乐器类又有——横笛、竖笛、排萧、短箫、口笛、埙等最特殊的代表乐器。

乐器《——边棱气鸣乐器《——埙（是乐器也是边棱气鸣乐器）通过继承，在子类类型和父类类型间建立起一种is-a关系。

Java支持单继承，而不支持多继承

所有的类都隐式或显示地继承自类Object。

为了显示地为当前即将构造的对象调用父类构造方法，采用了super关键字。他意味着把当前对象看成父类的一个实例。

覆盖(overriding)子类覆盖父类的方法，将子类传与父类的引用调用的还是子类的方法

抽象类

声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况.抽象就是从多个事物中将共性的，本质的内容抽取出来。不能创建abstract 类的实例。

然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。

抽象类使用abstract关键字修饰。抽象类无法实例化，即不能用new关键字创建一个抽象类的对象。

抽象方法：

抽象方法使用abstract关键修饰。抽象方法需要定义在抽象类中。抽象方法有别于具体方法，是一种有声明无实现的方法。

抽象方法与抽象类的关系：

包含抽象方法的类一定是抽象类，此时该类一定要声明成abstract class。如果一个类是抽象类，那么该类即可以包含抽象方法，也可以包含具体方法。

抽象类的继承：

如果在子类继承一个抽象类的情况下，该子类必须要实现父类中所定义的所有抽象方法；否则，该子类必须声明成一个abstract class。

内部类分为: 成员内部类、静态嵌套类、方法内部类、匿名内部类。

为什么要使用内部类 ？

每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。从这个角度看，内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了“多重继承”。

成员内部类

class Outer {

        class Inner{}

}

方法内部类(1)、方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。(2)、方法内部类对象不能使用该内部类所在方法的非final局部变量。public class Outer {

    public void doSomething(){
        
        class Inner{
            public void seeOuter(){
                
            }
        }
    }
}

匿名内部类在使用匿名内部类时，要记住以下几个原则：1匿名内部类不能有构造方法2匿名内部类不能定义任何静态成员、方法和类。3匿名内部类不能是public,protected,private,static。4只能创建匿名内部类的一个实例。5一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。6因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。

接口

在类的继承中，只能做单重继承，而实现接口时，一次则可以实现多个接口，每个接口间使用逗号“,”分隔。这时就可能出现常量或方法名冲突的情况，解决该问题时，如果常量冲突，则需要明确指定常量的接口，这可以通过“接口名.常量”实现。如果出现方法冲突时，则只要实现一个方法就可以了。

    使用interface来定义一个接口。接口定义同类的定义类似，也是分为接口的声明和接口体，其中接口体由常量定义和方法定义 两部分组成。定义接口的基本格式如下：

     [修饰符] interface 接口名 [extends 父接口名列表]{[public] [static] [final] 常量;
                 [public] [abstract] 方法;
              }

public interface CalInterface   
{  
    final float PI=3.14159f;//定义用于表示圆周率的常量PI  
    float getArea(float r);//定义一个用于计算面积的方法getArea()  
    float getCircumference(float r);//定义一个用于计算周长的方法getCircumference()  
} 

接口在定义后，就可以在类中实现该接口。在类中实现接口可以使用关键字implements，其基本格式如下：
[修饰符] class <类名> [extends 父类名] [implements 接口列表]{
}

多态（Polymorphism）：父类型的引用可以指向子类的对象。

多态用于参数，可以在方法的参数中传入其父类类型，在运行时会根据实际的运行时类
型来在方法中进行相应的操作。
多态一般用在方法的参数上
void feed(Animal a){
a.eat();
}
调用的时候 feed(new Dog());
//运行时，调用的是 Dog 类中覆盖的 eat()方法
2、多态用于返回值，可以在方法的返回值类型上是用其实际返回值的父类型，在使用其返
回值时也不关心其实际类型。
public static Animal getAnimal(int type){
if (type==0) return new Dog();
else return new Cat();
}
屏蔽子类差异，可扩展（只修改方法的实现，不必修改方法的声明）
3、Animal a= new Dog();
a.age;
//访问属性是没有多态的，访问的是引用的 age 属性
a.eat(); //调用 Dog 类中覆盖 Animal 类中的 eat()方法，多态
4、Animal a= new Dog();
method(a);
运行结果调用参数是 Animal 类对象的那个 method()方法
方法的重载只看引用类型，跟引用指向的对象类型没有关系