黑马程序员_java之面向对象

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

*面向对象：

定义：是一种思想，是一种符合现实生活人们思考习惯的思想。

1、面向过程 强调过程，执行者

2、面向对象 强调对象，指挥者

举例：大象放进冰箱里：

面向过程：打开冰箱——存储食物——关闭冰箱（面对三个动作）

（执行这些功能）

面向对象：（冰箱）打开冰箱——存储食物——关闭冰箱（动作）

（面对的是一个事物“冰箱”，这个事物也称为对象）

面向过程PK面向对象：

面向对象是将具体的动作封装到事物当中，那么就不用再面对动作，而是直接面向对象。找到对象，就已经具备了这些动作。

3、面向对象思想的特点：

---它是一种更符合人们思考习惯的思想

---它是复杂的内容简单化

---它是我们从执行者变成了指挥者

请解释面向对象的思想？

4、面向对象的特点：

---封装

---继承

---多态

面向对象的面试回答：

它本身是符合现在人们生活中的思想习惯，是一种思想；它的出现能让生活中复杂问题简单化，它可以让我们从执行者变成指挥者，指挥做事情。

面试官，其实你就是在用面向对象的思想在思考问题，公司里下面的工作需要人来做，即使你都可以做，但是也需要更多的人来帮你做。而你就是指挥者，下属的员工就是执行者。

类和对象：

1、类 对现实世界中事物的描述(属性和方法)

2、对象 现实世界中实际存在具体的个体

3、对象的使用以及内存图 new

4、局部变量和成员变量

（1）局部变量：（栈内存）

定义：只在某个程序块或只在方法体内有效。

        局部变量在使用前必须初始化，系统不会对局部变量进行默认初始化。

（2）成员变量：（堆内存）

（3）定义：不在方法体也不在程序块中的变量。只要对象被引用，成员变量就将存在。类中，对整个类有效。

5、变量初始化：

所有的局部变量在使用之前，都必须初始化（即必须要有值），手动赋值。

在初始化变量时，应该把变量名写在左边，随后是赋值操作符“=”，然后再在右边加上一个恰当的java表达式或值。

变量的初始化有两种方法：

（1）在声明变量时就同时给它赋一个值：int i = 4;

（2）先声明变量，然后再在适当的时机给它赋值：

int k ; 

......

k = 10;

*封装：

定义：把实现细节隐藏，对外提供公共的访问方式，在java中最常见的就是把成员变量用private修饰，提供get/set方法。

1、封装的好处：便于重复使用，安全性高。

2、private权限修饰符（代码体现）

class Demo

{

private int age;

public void setAge(int age)

{

if(age>100 || age<0)

{

System.out.println("年龄有误");

}

else

{

this.age = age;

}

}

public int getAge()

{

return age;

}

}

构造函数

1、用途：用于创建对象，也有可能要进行初始化。

A：格式 类名(){//code}

B：Person(){}

2、特点 你不给，系统会自动给一个空参构造，你给了，系统就不给了。

3、重载构造函数

重载特点：与返回值类型无关，只看参数列表。

A：Person(){}

B：Person(String name){}

C：Person(int age){}

D：Person(String name,int age){}

注意：构造还可以用于给属性赋值。

*继承(extends)：

定义：子类具有父类的所有属性和方法，没有构造器

1、继承的体系结构：就是对要描述的事物进行不断的向上抽取，就出现了体系结构。

--- 先学习顶层内容，因为它是共性内容。

--- 一般使用的时候使用的是底层的类。

2、继承的好处：

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

B：继承的出现，让类与类之间产生了关系，extends来表示，这个关系的出现，为后面我们讲面向对象的第三个特点多态打下了基础。

3、特点：

A：java只支持单继承。父类VS多子类，子类VS一父类。

B：java支持多重(层)继承。父类——子类——孙子类——重孙子类。

4、注意：

A：子类可以直接访问父类中的非私有的属性和行为。

B：不要仅为了获取其他类中部分功能而去继承。

C：类与类之间要有所属( " is a " )关系，xx1是xx2的一种。

5、继承后子父类之间成员的关系

(1)成员变量

class Father

{

int num1 = 5;

}

class Son extends Father

{

int num1 = 20;

int num2 = 10;

public void show()

{

int num1 = 30;

System.out.println("num1:"+num1);

System.out.println("num2:"+num2);

//局部范围内有的变量，如果我想使用成员变量，this

System.out.println("this num1:"+this.num1);

//就想子类中访问父类中和子类同名的变量super

System.out.println("father num1:"+super.num1);

}

}

总结：使用子类中的成员变量时，首先看局部有没有和成员变量同名的，如果有就是用局部的。

  其实，在子类的成员变量里面找，如果有，直接输出。

  最后，在父类中找同名的变量，如果有，就输出父类的值。否则报错。

(2)成员方法

class Father

{

public void show()

{

System.out.println("father show");

}

}

class Son extends Father

{

public void show()

{

System.out.println("son show");

}

public void show1()

{

System.out.println("son show1");

}

}

总结：在使用子类的成员方法时：首先在子类中找，其次在父类中找。否则，报错。

  super可以在子类中使用父类的成员方法。

子类中存在和父类成员方法同名的这种现象，叫做重写，复写，覆盖。

重写(override)和重载(overload)的区别：

重载的特点：

1--在同一类中。

2--方法名相同，参数列表不同。

重写的特点：

1--要有继承关系。在子父类中

2--方法的声明相同。(方法名和参数列表都相同)

----覆盖时，子类方法权限一定要大于等于父类方法权限

----静态只能覆盖静态。

(3)构造方法

class Father

{

Father(){}

Fahter(int age)

{

System.out.println("father age:"+age);

}

}

class Son extends Father

{

Son()

{

//默认这里有一个东西 super();

//this(20);

System.out.println("son");

}

Son(int age)

{

super(age);

System.out.println("son age:"+age);

}

}

Son s = new Son();  //father;son

Son s = new Son(20);//father;son age:20

总结：子类中所有的构造方法默认都会访问父类中空参数的构造方法。

  因为每一个构造方法的第一行都有一条默认的语句super();

              当父类中没有空参数的构造方法时，子类的构造函数必须通过this，

      或者super语句指定要访问的构造方法。类手动提供无参构造方法。

      this(...):调用本类中的构造方法

      super(...):调用父类中的构造方法

以前：构造方法用于创建对象，并进行初始化。

      class Person

      {

Person(){}

Person(int age)

{

this.age = age;

}

Person(int age,String name)

{

this(age);

//this.age = age;

this.name = name;

}

      }

//Person p =new Person();  //系统默认给出无参构造

        //当你手动给出构造方法后，系统就不会再给出默认的空的构造方法。

//手动无参数，如果你想给属性赋值或者做一些初始化，无参不要删

class Demo

{

private String name;

Demo(){}

public void setName(String name)

{

this.name = name;

}

public String getName()

{

return name;

}

}

*抽象类(abstract)：

定义：只抽取了很多类的方法的声明，为了保证不出问题，方法声明用abstract修饰。

1、抽象类的特点

A：一个类如果有了抽象方法，那么这个类必须是抽象类。抽象类里边可以 没有抽象方法。

B：抽象类是不能够被实例化的。不能够创建对象的。

C：如果一个类继承抽象类，那么，它要么实现抽象类中的所有抽象方法，

要么本身也是抽象类。

3、抽象类的成员特点：

A：成员变量：子类可以直接继承抽象类中的成员变量。(抽象类中的成员变量可以和以前是一样的)

B：成员方法：抽象类中分为两种方法，一种是抽象方法，这种方法在子类中必须要被实现。一种是普通的方法。可以被子类直接继承使用。

C：构造方法：抽象类不能被实例化，那么它有构造方法吗?抽象类是class，那么它就有构造方法。它的构造方法为了让子类实例化。

4、抽象类的相关问题：

A：抽象关键字abstract不可以和哪些关键字共存？

private：私有的，外部直接无法访问。

static：那么这个时候抽象方法就可以可以通过类名调用，但是这  样是没有意义的。

final：final修饰的方法不能被重写。所以它和abstract冲突。

B：抽象类中可以没有抽象方法，防止其他类创建该类对象。

*接口(interface)：

定义：当一个类中的方法都是抽象的时候，你没必要定义为抽象类，定义为接   口就可以了。

1、解决了java中只能单继承的问题。(对多继承进行了优化)

A：类与类：只能是单继承。

B：接口与接口：可以是单继承，也可以是多继承。

C：类与接口：可以是单实现，也可以是多实现。

2、成员特点：

A：只有成员变量和成员方法。

B：成员变量：默认修饰符 public static final

**int x = 20;

**其实是这样的 public static final int x = 20;

C：成员方法：默认修饰符 public abstract

**void show();

**其实是这样的 public abstract void show();

建议：自己手动加上修饰符。

4、接口特点：

A：接口是对外暴露的规则

B：接口是功能的扩展

C：接口降低了程序的耦合性。

**内聚(自己实现功能的能力) 

**高内聚，低耦合。

举例：主板和CPU,USB接口,电源插座。

D：扩展说了下接口的理解

**狭义的理解就是java中的接口。

**广义的理解就是：任何定义的规范都是接口。

5、接口实现的语法格式：A a = new B();

public interface MyInner{

public abstract void fun();

}

class MyClass implements MyInner{

public void fun(){

}

}

6、接口和抽象类的区别：

A：抽象类只能被单继承；接口可以被多实现。

B：抽象类中的成员：

          成员变量:可以是常量，也可以是变量。

   成员方法:可以是抽象的，也可以是非抽象的。

   构造方法:虽然不可以创建对象，但是可以给子类实例化用。

      接口中的成员：

成员变量：只能是常量。默认修饰符 public static final

成员方法：只能是抽象的。默认修饰符 public abstract

C：抽象类中定义的是体系结构中的共性的内容。

接口中定义的是对象的扩展功能。

D：抽象类被继承表示的是："is a"的关系。xx是yy中的一种。

接口被实现表示的是: "like a"的关系。xx像yy中的一种。

常见接口总结：

Collection

List

Set

Map

Comparable

Comparator

Runnable

Serializable

FilenameFilter

*多态：

定义：同一个对象在不同时刻所对应的状态。

例如：水（气态、液态、固态）

**方法重载(静态多态)

**方法重写(动态多态,对象多态)

1、对象多态的前提

A：类与类(或接口)要有继承(或实现)关系。

B：一定要有方法的重写。

C：一定要有父类或者接口的引用指向子类的对象。

2、多态思想：可以指挥同一类型的一批对象做事情。多态的出现让我们复杂的    问题简单化了。

3、多态中成员的特点：

Fu f = new Zi();

A：成员变量：编译和运行都看Fu。

B：非静态方法：编译看Fu，运行看Zi。

C：静态方法：编译和运行都看Fu。

4、代码体现：

class Fu{

int num = 10;

public void show(){

Sop(“show Fu”);

}

}

class Zi extends Fu{

int num = 20;

public void show(){

sop(“show Zi”);

}

}

class Test{

public static void main(String[] args){

Fu f = new Fu();//创建父类对象

f.show();//show Fu，调用Fu的show方法

Sop(f.num);//10

Zi z = new Zi();//创建子类对象

z.show();//show Zi，调用Zi的show方法

Sop(Zi.num);//20

//多态A a = new B();

Fu f = new Zi();

f.show();

Sop(f.num);//10

}

}