黑马程序员--面向对象

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

面向对象

面向对象概念

面向对象是相对面向过程而言，面向对象和面向过程都是一种思想。

面向过程：强调的是功能行为



面向对象的特点

是一种符合人们思考习惯的思想，可以将复杂的事情简单化，将程序员从执行者转换成了指挥者。

-----------------------------------------------------------------
面向对象三大特性：
封装

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

好处：

    1.将变化隔离。

    2.便于使用。

    3.提高重用性。

    4.提高安全性。

封装原则：

   1.将不需要对外提供的内容都隐藏起来。

   2.把属性都隐藏，提供公共方法对其访问。如，getXXX，setXXX。

class Person{
//private：私有，是一个权限修饰符，用于修饰
//不希望别人直接访问赋值，需要通过私有化把属性进行隐藏
private int age ;

//通过提供set、get公共方法对其访问
public void setAge( int a){
//在set方法内可以对属性的赋值进行限制
if (a > 0 && a < 130){
age = a;
} else
System.out .println("错误的数据" );
}

public int getAge(){
return age ;
}

void speak(){
System.out .println("age = " + age);
}
}

class PersonDemo{
public static void main(String[] args){
Person p = new Person();
//通过其他方式访问
p.setAge(20);
p.speak();
//赋值不合法，set方法就不允许成功赋值
p.setAge(-20);
}
}

二，继承

    通过extends关键字让类与类之间产生继承关系。

    多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行

    为，只要继承那个类即可。多个类可以称为子类，单独这个类称为父类或者超类。

  好处：

     继承的出现提高了代码的复用性。

     继承的出现让类与类之间产生了关系，提供了多态的前提。

     Java只支持单继承，不支持多继承。

     一个类只能有一个父类，不可以有多个父类。

   原因：

     因为多继承容易出现问题。两个父类中有相同的方法，子类到底要执行哪一个是不确定的。

class Person{
String name;
int age ;
}

class Student extends Person{
void study(){
System.out.println("student study..." + age);
}
}

class Worker extends Person{
void work(){
System.out.println("worker work..." + age);
}
}

class ExtendDemo{
public static void main(String[] args){
Student s = new Student();
s. name = "zhangsan" ;
s. age = 20;
s.study();

Worker w = new Worker();
w. name = "lisi" ;

w. age = 30;

w.work();

}

}

三，多态

多态性简单说就是一个对象对应着不同类型。

体现：

父类或者接口的引用指向或者接收自己的子类对象。

作用：

多态的存在提高了程序的扩展性和后期可维护性。


前提：

1.需要存在继承或者实现关系。

2.需要有覆盖操作。
好处：

提高了代码的扩展性，前期定义的代码可以使用后期的内容。

弊端：

前期定义的内容不能使用（调用）后期子类的特有内容。

abstractvoideat();
}

classDogextendsAnimal{
voideat(){
System.out.println("啃骨头");
}
voidlookHome(){
System.out.println("看家");
}
}
classCatextendsAnimal{
voideat(){
System.out.println("吃鱼");
}
voidcatchMouse(){
System.out.println("抓老鼠");
}
}
classPigextendsAnimal{
voideat(){
System.out.println("饲料");
}
voidgongdi(){
System.out.println("拱地");
}
}
classDuoTaiDemo{
publicstaticvoidmain(String[]args){
Catc=newCat();
Dogd=newDog();

method(c);
method(d);
method(newPig());
}

publicstaticvoidmethod(Animala){
a.eat();
}
}

下面说一说接口与一些关键字：
接口

当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是接口。

格式：interface{}

接口中的成员修饰符是固定的：

成员常量：publicstaticfinal

成员函数：publicabstract

由此得出结论，接口中的成员都是公共的权限。

接口是对外暴露的规则。

接口是程序的功能扩展。
注意：

1、虽然抽象类中的全局变量和抽象方法的修饰符都可以不用写，但是这样阅读性很差。所以，最好写上。

2、类与类之间是继承关系，类与接口直接是实现关系。

3、接口不可以实例化，能由实现了接口并覆盖了接口中所有的抽象方法的子类实例化。否则，这个子类就是一个抽象类。

interface Demo{
public static final int NUM = 4;
public abstract void show1();
public abstract void show2();
}

class DemoImpl implements /*实现*/Demo{
public void show1(){}
public void show2(){}
}

class InterfaceDemo{
public static void main(String[] args){
DemoImpl d = new DemoImpl();
System.out.println(d.NUM);
System.out.println(DemoImpl.NUM);
System.out.println(Demo.NUM);
}
}

static 关键：

1，被static修饰的成员变量，被所有对象所共享。

2，静态随着类的加载而加载，随着类的消失而消失。

3，优先于对象存在。

4，静态成员可以直接被类名所调用。

static的使用注意事项。

1，静态方法只能调用静态成员，不能调用非静态成员。
非静态方法可以调用静态成员，也可以调用非静态成员。

2，在静态方法中不允许出现this，super关键字。
this代表对象，而静态方法执行时还没有对象呢！

3，主函数是静态的。

静态是有访问局限性的，只能访问静态的内容。 

静态成员变量和非静态成员变量的区别？

1，

非静态成员变量又称为实例变量。

静态成员变量又称为类变量。

2，

非静态成员变量，随着对象的创建而存在，随着对象的消失而消失。

静态成员变量，随着类的加载而存在，随着类的消失而消失。

3，

非静态变量存在于对象堆内存中。

静态变量存在于方法区中。

4，

非静态变量只能被对象所调用。

静态变量可以被类名调用，也可以被对象调用。

--------------------------------------------------------

this:代表的是一个对象。
代表哪个对象呢？
哪个对象调用this所在的函数，this就代表哪个对象。
this就是当前对象的一个引用。

this:表现形式一：当局部变量和成员变量同名的时候，可以用this来区分。

:表现形式二：构造函数之间的调用可以使用this关键字，后面跟上小括号，指定具体的实参即可明确要调用的构造函数。
特殊情况：注意：调用本类中构造函数的this语句必须定义在构造函数的第一行
因为初始化动作要先完成。 

------------------------------------------------------------
final关键字的特点：

1,final是一个修饰符，既可以修饰类，又可以修饰方法，还可以修饰变量。

2,final修饰的类不可以被继承。

3,final修饰的方法不可以被覆盖。

4,final修饰的变量是一个常量，只能赋值一次。
为了将固定的一些数据方便使用，会给这些起一个容易阅读的名称，
为了防止名称存储的数据改变。用final修饰。
一般为final修饰的变量名称都是大写字母组成，如果有多个单词，
每个单词之间用下划线分隔。