Java学习第六_八天：面向对象__继承_接口_多态

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

面向对象

1、static关键字

2、Main函数

3、静态什么时候使用

4、静态应用-工具类

5、帮助文档的制作

6、静态代码快

7、对象的初始化过程

8、对象调用成员过程

9、单例设计模式

10、单例设计模式二

 

static关键字（独自开辟了空间的）

1、Static关键字是用于修饰成员（成员变量、成员函数）

2、修饰成员后，该成员随类的加载而加载--同时，随类的消失而消失

而且修饰的成员优先于对象存在，并且是共享的数据，可直接类名调用。

3、静态是只能静态调用的，而且静态是不能写this、super关键字的！因为是共享数据嘛，所以别想着对象调用。

4、主函数就是静态函数哟

5、被静态修饰的好处：节省空间、方便调用

不好的地方：生命周期长、访问有局限（只能静态访问静态）

 

静态什么时候使用

当变量是共享数据的时候使用静态，当函数功能是被共有的时候使用静态。

 

静态应用-工具类

私有化工具类的构造函数，可以避免创建对象而不直接类名调用的情况

 

帮助文档的制作

/**

@author 作者

@version 版本

*/

 

/**

......类的介绍

@peram -类的参数接受

@return -返回值

*/

制作帮助文档的代码：doc:javadoc -d myhelp(文件名) -author -version 类名

注意几点：帮助文档的类要Public.私有的方法是不被提取的.构造函数默认权限是和该类相同的

 

静态代码块

格式：static{}

一样是随着类的加载而加载，只执行一次，用于给类初始化

 

对象的初始化过程

举例：Person p = new Person();

1、因为new用到了Person.class 所以会先找到Person.class文件并且加载到内存中去

2、执行该类中的static代码块~如果有的话，给person.class类进行初始化

3、在对内存中开辟空间，分配内存地址值

4、在堆内存中建立对象的特有属性，并进行默认初始化

 

单例设计模式

保证对象的唯一性。

为了避免其它程序过多建立该类对象，先进制其它程序建立该对象。

还为了让其它程序可以访问到该类对象，只好在本类中自定义一个对象

为了其它程序方便访问自定义对象，可以对象提供一些访问方式

 

步骤：

将构造函数私有化

在类中创建一个本类对象

提供一个方法获取本类对象

public class Simple {

public static void main(String[] args) {
// TODO Auto-generated method stub

}
}
//饿汉式
class Hunger{
private Hunger(){}//私有化构造函数，让别的程序无法建立该类对象
private static Hunger l = new Hunger();//创建一个本类对象，让其它程序可以调用该对象
public static Hunger getHunger()//对象提供获取对象的方法
{
return l;
}
}
//懒汉式
class Lazy{
private Lazy(){}
private static Lazy l=null;
public static Lazy getLazy()
{
if(l==null)
{
synchronized(Lazy.class)
{
if(l==null)
l = new Lazy();
}
}
return l;
}
}

下面再列举后面会接触到模式：
模板设计模式：

在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去。由该类的子类去完成。

举个例子：建立了一个计算时间的Time class类，在start和end之间设定一个方法接受不确定的时间！这个方法就为timeCode()方法！然后再定义个一TimeCode类！让该类去继承Time类，并且覆写了里面的timeCode方法！在该方法中输入自己想运行的代码！~其中timeCode方法中的代码就是不确定的因素！~

装饰设计模式：

当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有功能，提供加强功能。那么自定义的该类称为装饰类。

后面会有提到！

UNTIL7

面向对象

1、继承的概述

2、聚集关系

3、子父类中变量的特点

4、-------------------------------覆盖

5、子类中构造函数的特点-子类实例化过程

6、Final关键字

7、抽象类

8、抽象类two

9、抽象类练习

10、模版方法模式

11、接口

12、接口的特点

13、借口举例体现

 

继承的概述

继承要使用到关键字：extends.

继承提高了代码的复用性，使类与类之间产生了关系（也导致了多态的产生）。

继承是必须类与类之间有所关系才能进行继承

 

组合与聚合

组合和聚合有很大区别，这个区别不是在形式上，而是在本质上：

比如A类中包含B类的一个引用b，当A类的一个对象消亡时，b这个引用所指向的对象也同时消亡（因为没有引用指向它），这种情况叫组合

反之，如果引用b所指向的对象还会有另外的引用指向它，这种情况叫聚合。

       实际开发中代码会这样写：

       组合：A类的构造方法里创建B类对象。也就是，当A类创建A类对象             时，B类对象随之创建，A类对象消亡，它所包含的B类对象也随之消亡。

       聚合：A类对象在创建时不会立即创建B类的对象，而是等待一个外界的对象传给它，传给它的这个对象是A类创建的。

       现实生活中的例子：

           组合：人与人的手脚；

           聚合：人与他的电脑。

Java语言中，值支持单继承（但这是不严谨的，因为有接口的出现，多继承以另一种方式实现了）.

但是Java中支持多层继承。

 

子父类中变量的特点

类中的成员有变量、函数和构造函数。

使用super关键字可以调用父类引用。

继承中子类变量的特点：若子类出现非私有变量，使用This可以调用本类变量，使用super可以调用父类的。

 

子父类中函数覆盖

有时候子类继承了父类可是函数需要扩展，会对函数进行重写，我们称之为覆盖，类名是和父类一致的，保留了功能定义。而且子类覆盖父类方法，权限必须大于等于父类

 

子类中构造函数的特点-子类实例化过程

子类继承父类之后，自身构造函数都有一个隐式的super()方法。（因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时，要先访问一下父类中的构造函数。）

Final关键字

Final关键字修饰类、函数和变量。

被修饰的函数不能覆盖，被修饰的变量只能赋值一次，被修饰的类不能被继承。

抽象类

抽象类要用到关键字abstract

抽象可以修饰类和方法，抽象的对象是不能创建对象的，也就是说不能New

特点：

抽象方法必须在抽象类中，而抽象类中是可以没有抽象方法的

子类继承抽象类要覆写全部方法，如果没有覆盖全，那么子类也是抽象方法

 

抽象类练习

public class exception {

/**
* 假如我们在开发一个系统时需要对员工进行建模，员工包含3个属性：姓名、工号以及工资
* 经理也是员工，除了含有员工的属性外，另外还有一个奖金属性。请使用继承的思想设计出员工类和经理类
* 要求类中提供必要的方法进行属性访问
*
* 员工类：name id pay
* 经历类:继承了员工，丙有自己特有的bonus
*/
public static void main(String[] args) {

}

}
abstract class Employee{
private String name;
private String id;
private double pay;
Employee(String name,String id,double pay)
{
this.name = name;
this.id = id;
this.pay = pay;
}
public abstract void work();
}
class Manager extends Employee{
private int bonus;
Manager(String name,String id,double pay,int bonus)
{
super(name,id,pay);
this.bonus = bonus;
}
public void work()
{
System.out.print("Manager work");
}
}
class Pro extends Employee{
Pro(String name,String id,double pay)
{
super(name,id,pay);
}
public void work()
{
System.out.print("Pro work");
}
}

 总结下：

（1）abstract 关键字，和哪些关键字不能共存。

final：被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类。

private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。而抽象方法出现的就是需要被复写。

static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。可是抽象方法运行没意义。

       （2）抽象类中是否有构造函数？
有，抽象类是一个父类，要给子类提供实例的初始化。

接口

格式：interface{}

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

成员常量：public static final

成员函数：public abstract

 

 

类与接口之间的实现方式靠关键字：implements

接口是不可能创建对象的，而且子类全重写之后才可以创建对象，不然子类也还是接口

 

接口是程序的扩张

接口是对外暴露的规则

 

接口的特点

接口是对外暴露的规则

接口是程序的功能扩展

接口可以用来多实现

类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口

接口与接口之间可以有继承关系

 public class time {

public static void main(String[] args) {
//记时
long beg = System.currentTimeMillis();
int sum=0;
for(int x = 0;x<1000;x++)
{
sum+=x;
}
System.out.println(sum);
long end = System.currentTimeMillis();
System.out.println(end-beg);
}

}

UNTIL8

面向对象-多态

1、概念

2、扩展性

3、转型

4、示例

5、成员特点

6、主板示例

7、扩展示例

8、Obejct类中的equals()

9、Obejct类中的toString()

 

概念

多态的理解：多态就像生物学中的分类！父类属于动物，而子类是各种各样的特色动物

A多态的体现：父类引用指向子类对象

B 多态的前提：必须类与类的关系（继承，实现）/存在与覆盖

C 多态的优势：提高程序扩展性

D多态的弊端：只能使用父类的引用访问父类中的成员

 

 

示例

public class Duotai {

public static void main(String[] args) {
// 多态的示例
DoStudent ds = new DoStudent();
ds.doSome(new BaseStudent());
ds.doSome(new AdvStudent());
}

}
abstract class Student{
public abstract void study();
public void sleep()
{
System.out.println("睡觉");
}
}
class BaseStudent extends Student
{
public void study()
{
System.out.println("基本班的在学习");
}
public void sleep()
{
System.out.println("基础班的站着睡觉");
}
}
class AdvStudent extends Student{
public void study()
{
System.out.println("高级班的在学习");
}
public void sleep()
{
System.out.println("高级班的躺着睡");
}
}
class DoStudent{
public void doSome(Student stu){
stu.study();
stu.sleep();
}
}


在多态中成员特点

成员函数特点：

在编译时期：参阅引用型变量所属的类中是否有调用方法。如果有，方法通过，没有，编译失败。

在运行时期：参阅对象所属的类中是否有调用方法。

 

静态成员函数特点：

无论编译或者运行时期，都参考左边的引用型变量。

 

成员变量特点：

无论编译和运行，都参考左边（引用型变量所属的类）

主板示例

 public class Mainb {

public static void main(String[] args) {
// 模拟主板运行示例
MainBoard mb = new MainBoard();
mb.run();
mb.usePCI(new NetCard());
}

}
interface PCI
{
public void open();
public void close();
}
class MainBoard{
public void run()
{
System.out.println("MainBoard run");
}
public void usePCI(PCI p){
if(p!=null)
{
p.open();
p.close();
}
}
}
class NetCard implements PCI{
public void open()
{
System.out.println("NetCard open");
}
public void close()
{
System.out.println("NetCard close");
}
}

Obejct类中的equals()

Public boolean equals(Object obj){}

 

instanceof

Obejct类中的toString()

Integer.toHex

getClass()

getName()

 

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