Java——第五章（面向对象编程）

提到面向对象编程，我要提到一点，这个应该是java中最核心，也是最难的一部分了，莫非难于上青天？？。

但是，，，不要担心，小编自会让你攀顶，突破阻碍了。。

先来谈谈什么是面向对象，面向对象的思想是什么？

java是最接近自然语言的高级编程语言，万事万物皆对象，树是一个类，鸟也是一个类，柳树是一个对象，麻雀是一

个对象，空气是一个对象，水是一个对象，人也是一个对象……

而这些对象的特征，形象就是对象的属性，而这些对象的行为动作，就是对象的方法。

以现实世界中的事物为中心来思考问题，认识问题，并根据这些事物的本质特点，把它们抽象地表示为系统中的对

象，作为系统的基本构成单位，这样，世界似乎就显示的很条理了。。

在面向对象这一章会提到四个概念，类、对象、属性、方法。

类对于对象是抽象的，类不能直接使用，对象可以，对象是属于类的，通过对象来访问类，类=属性+方法，同样，对

象也=属性+方法。

类的属性也就是对象所具有的特征，例如对象的名字。属性中有权限修饰，属性类型，属性名。

eg：private String name;

权限修饰：public、protected、default、private。

public ： 公共的，被其修饰的属性或方法可以在本项目中调用。

protected： 被保护的，被其修饰的属性或方法可以在本包内调用。

default ： 默认的，被其修饰的属性或方法可以在本包内调用。

private ： 私有的，被其修饰的属性或方法可以在本类内调用。

属性类型同第二章的变量类型、String。

万事万物皆对象，方法是对象的行为动作，实现的功能。方法又分为普通功能方法和构造方法。

普通方法：方法：用来实现某个功能。

权限访问 返回类型  方法名（参数列表）
{
方法体
}

eg： public void Add（int a ，int b）

{

  System.out.println("两数之和："+a+b);

}

构造方法：无参构造方法和全参构造方法，部分 参数基本不用。

无参构造方法：

public 类的名字（无参数）
{
}

全参构造方法：

public 类的名字（类所拥有的全部属性）
{
属性的初始化
}

java中有三大特性，信息的封装和隐藏、继承、多态。

信息的封装和隐藏是指权限修饰用private修饰，用来限制外部访问。标准javabean就是典型的信息封装。

这里提到的javabean是指一种类的形式。具有私有属性、构造方法（全参构造方法、无参构造方法）、

setters() and getters()方法、to String()方法、hashcode() and equals()方法。

拥有这些属性或方法的类，就是一个标准的javabean，javabean是java中的数据流通格式。

setters and getters方法用来设置和获得类的私有属性，to String方法用来打印出属性的值，

hashcode和equals方法用来判断地址和内容是否相等。那么，

既然java语言是最接近自然语言的，子女是可以继承父母的东西，同样java中也有继承关系，为了减少代码的重复编

写，使得代码更简洁，更接近自然语言，如果父子关系，子

类继承父类，继承而得到的类称为子类，被继承的类称为父类。例如学生类继承人类，学生是子类继承父类人类，人

类有名字，年龄等属性，同样学生类中也有，不用重复写继

承过来的属性或方法，拥有父类的全部属性和方法，不过在父类中用private修饰的子类访问不到。

例如：若已存在子类b，子类a要继承子类b，public class a extends b{   }。a类继承b类，a为子类，b为父类。

a中具有b中所有的属性和方法。

子类不能继承父类中访问权限为private的成员变量和方法。子类可以重写父类的方法，及命名与父类同名的成员变

量。重写时方法名必须一致。

父类中所有属性和方法 子类都有java中是单继承，一个子类只能拥有一个父类。

子类可以自行添加自己的属性和方法。继承过来的属性是 独特的属性，必须通过调用父类的构造方法来初始化。

super（）  必须放在第一行  。

提到继承，不得不说一下抽象类，抽象类是对于类的抽象，通过子类来具体化。描述某些方法体不确定的事物。

在开发中，有时候不知道具体实施的方法是什么，但是确确实实有这个方法存在，所以出现了抽象类。

例如：都知道工具类中有工具的使用方法，但是没有指定哪个工具，工具中的方法是不确定，不明确的，所有可以用

抽象类代替工具方法。

这种只给出方法定义而不具体实现的方法被称为抽象方法，抽象方法是没有方法体的，在代码的表达上就是没

有“{}”。

那抽象类长啥样？怎么用呢？

抽象类需要在class前面添加abstract修饰，形式长这样：

public abstract class Tool
{

（可能存在的）

  属性
  普通功能方法
 抽象方法 public abstract void xxx ();
 构造方法

}

子类继承抽象类。需要重写抽象类中所有抽象方法（切记！），同样继承父类属性方法，普通方法不需重写，不过抽

象方法得重写。

public class subclass extends Tool{
public void xxx()
    {       }
}

自己呢，总结出抽象类中需要注意的地方：

1.抽象类中可以有抽象方法，也可以没有抽象方法。

2.抽象方法一定在抽象类中。

3.抽象类可以和普通方法一样拥有属性和方法。

4.抽象方法甚至可以拥有构造方法，用来给子类使用super（）初始化从父类继承过来的属性。

5.抽象类可以有static修饰的方法。

可能也有很多人有疑问，关于static，super这些东西不太了解，那么，接下来就是讲一下咱们常见到的关键字。

常见的关键字大概有这么些个： this、super、final、static。

this呢，代表着当前类的对象，在创建这个类的时候，类中不知道main方法中具体的对象叫什么，所以表示着未来对

象的引用，eg： Student s = new Student()；

在构造方法中的this指的就是之后创的student 的s对象。通过this.方法相当于s.方法来调用。this调用本类的构造

方法也是要放第一行。

super关键字，代表着父类，super.调用的方法为父类的方法，super也可以调用父类的属性。常在构造方法中第一行

用super继承父类的方法或属性。

final，意思就是最后的，最终的。顾名思义，都是最后了肯定不能对他加以改造了。。

1.用final 修饰的属性，一经初始化则不能修改（最后的，已定型）。

2.用final修饰的方法，不能被重写（最后了都，不能出现分歧）。

3.用final修饰的类，不能拥有子类，不可被继承（都是最后一代了。。）。

重点在于static这个关键字，static表示的是静态，是被所有对象所共享的。

1.不能和this，super关键字联用，因为static是静态的，不靠具体对象实施，基本上是和对象没关系，当然也是可

以对象调用，但一般不这么用，一般通过类直接调用属性或方法。

2.用static修饰的属性或方法，其实都是将他们放在了静态堆栈里面，为所有类所共享。属性一经改变，之后的引用

该属性都将改变。

静态堆栈里   如果两个对象一致  只创建一次。

3.static {
静态代码块
}

static代码块在加载类的时候先执行，之后如果有构造方法才执行构造方法。

所有被静态修饰的属性和方法为所有的对象共享。


静态代码块 优先于 任何方法和语句的执行。

提到加载类，说一下程序的运行顺序，

程序的执行顺序是先加载主类（若主类有static代码块，要先执行代码块中内容）----》执行main方法

然后加载其他类---》加载属性（父类---》子类）----》构造方法（父类---》子类）

之前咱们有讲到java是单继承，所以很多时候单继承不方便，那java有没有多继承的呢？答案是  有！接口就是多

继承的。

接口类似于标准。标准是用来制定，约束的。但实施者并不是标准，标准只是纸质说明而已，真正实施的还是安排的

人员。例如宿舍管理规则，违反后规则并不能惩罚你，而是

楼管大爷教育你。

标准定义：Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此

这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

接口的形式：

public interface 接口名{
public static final 属性类型 属性名;
public abstract 返回类型  方法名;
}

接口中的方法不允许有构造方法，方法均为抽象方法。

那么，问题来了，那怎么实现接口呢？接口实际上是抽象类的抽象，通过实现类来实现接口。

实现类实现接口用关键字implements 来修饰。

例如：public class User implements Person
{
重写所有抽象方法。
}

User类是实现类，实现Person接口的所有抽象方法。

接口可以是多继承，接口的实现也是多继承。

多重实现：
public class xxx1 implements inter1,inter2{

}

接口中的属性用常量，用static final修饰的变量名，就是常量。可以直接写常量类型加常量名。

默认为public static final。

接口中的抽象方法可以直接写返回类型和方法名，默认为public abstract 。

接口是抽象类的抽象。

接口似乎看起来和抽象类有点类似，但其实不是。。那咱们做一个区分。

1.抽象类是class   接口为interface

2.接口中属性只能是常量，抽象类属性不一定是常量。

3.接口中只能有抽象方法，抽象类中可以有普通方法，可以没有抽象方法。

4.抽象类中能定义static 方法，而接口中不允许有static方法，因为需要重写嘛。

5.抽象类可以有构造方法 ，  接口没有构造方法。

还剩下最后一个特性，多态。多态多态，顾名思义就是多种形态、状态。在面向对象语言中，接口的多种不同的实现

方式即为多态。

父类留有子类对象的引用，子类可以对父类进行赋值。

例如：

Student继承Person类           

Person p = new Student();

编译时p为Person类，运行后是Student类，父类留有子类的引用。很多时候将父类设为object类，因为他是所有类的

父类，创建他的对象，在各个方法中更容易管理，想要设置

成其中某一个类的对象，只需改变object中对象即可，通过强制类型转换。

还有一种说法，多态可以分编译时的多态和运行时的多态，编译时的多态即方法的重载，运行时的多态即方法的覆盖

（重写）。

有一个需要大家了解知道的对象，那就是成品的软件一般有三层架构，视图层，业务逻辑层和数据库连接层。视图层

可以是Android中设计界面，业务逻辑就是java后端运行的

代码，将业务逻辑层的数据用数据流通格式javabean封装起来，通过创建类的beandao，通过类的beandao实现顶层接

口设计，调用sql语句将javabean导入数据库。

整个第五章java面向对象程序编程基本上就讲完了，至于细节问题，之后发现会有补充。