码迷,mamicode.com
首页 > 编程语言 > 详细

Java学习-第三天

时间:2014-10-12 13:21:57      阅读:284      评论:0      收藏:0      [点我收藏+]

标签:blog   io   使用   ar   java   for   数据   sp   div   

07day
1.继承

继承:提高了代码的复用性,让类与类之间产生了关系,有了这个关系,才有了多态的特性。

Java语言中,Java只支持单继承,不支持多继承。
因为多继承容易带来安全隐患。当多个类中定义了相同的功能,当功能内容不同时,子类对象不确定要运行哪一个父类的功能。
但Java保留了这种机制 ,并且用一种体现形式来完成表示,多实现。

/*
class A
{
void show();
}
class B 
{
void show();
}
class C extends A,B
{

}

C c = new C();
c.show(); //如果上面继承关系成立,这是c.show()不知道运行哪个父类的show()方法。

*/

 


Java支持多层继承。

/*
class A
{
    void show();
}

class B extends A
{
    void show();
}
clsss C extends B
{

}
    B b = new B();
    b.show();
    C c = new C();
    c.show();

*/

 

2.子父类出现后,类成员的特点。

2.1 变量

如果子类中出现非私有的同名变量时,子类访问本类中的变量用this。子类要访问父类中的同名变量,用super。

class Fu
{
    int num = 6;
}
class Zi extends Fu
{
    int num = 42;
    void show()
    {
        System.out.println(super.num);
    }
}

class ExtendsDemo
{
    public static void main(String[] args)
    {
        Zi z = new Zi();
        System.out.println("z.num");
        z.show();
    }
}

 

2.2 子父类中的函数

当子类出现和父类一模一样的函数时,子类对象调用该函数,会调用子类函数的内容。这就是函数的另一个特性,重写(覆盖)。

当子类继承父类,就沿袭了父类的功能。当子类功能内容和父类功能不一致时,子类不必定义新功能,使用覆盖特性,保留父类的功能定义,并重写功能。

继承时的覆盖:
1.子类覆盖父类,必须保证子类的权限大于等于父类权限,才可以覆盖,否则编译失败。


2.静态只能覆盖静态

class Fu 
{
    void show()
    {
        System.out.println("fu show");
    }
}

class Zi extends Fu
{
    void show()
    {
        System.out.println("zi show");
    }
}

class ExtendsDemo
{
    public static void main(String[] args)
    {
        Zi z = new Zi();
        z.show();
    }
}                    

 

2.3 子父类中的构造函数

在子类对象进行初始化时,子类的构造函数默认第一行有一条隐式语句super(); 所以父类的空参数构造函数也会运行。并且子类所有的构造函数第一行默认都是super();
super():会访问父类中的空参数构造函数。

为什么子类一定要访问父类中的构造函数
因为父类中的数据子类可以直接获取,子类对象在建立时,需要先查看父类是如何对这些数据进行初始化的。

如果需要访问父类中指定的构造函数,可以通过手动定义super()语句的方式来指定。

当父类中没有空参数的构造函数时,子类必须通过手动super()语句来指定访问父类中的构造函数。

当然,子类的构造函数也可以通过手动指定 this(); 语句访问本类构造函数

class Fu
{
    Fu()
    {
        System.out.println("fu run");
    }
}

class Zi extends Fu()
{
    Zi()
    {
    //super();
    System.out.println("zi run");
}

Zi(String s)
{
    //super();
    System.out.println("zi run :"+s);
}

class ExtendsDemo
{
    public static void main(String args)
    {
        Zi z = new Zi();

        Zi z1 = new Zi();
    }
}        

 

3.final 关键字

3.1 final 可以修饰类、函数、变量。

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

/*
final class A
{
void show();
}

class B extends A //编译错误,不可继承
{
}
*/

3.3 final修饰的函数不可以被覆盖。

/*
class A
{
final void show();
}

class B extends A 
{
void show();//编译错误,不可覆盖
}
*/

3.4 final修饰的变量是一个常量,只能被赋值一次。

/*
class A
{
final double PI = 3.1415926;
void show()
{
PI = 3.14; //编译错误,只能被赋值一次。
}
}

*/

3.5 内部类只能访问被final修饰的局部变量。

4.抽象类 abstract

1.含有抽象方法的类都是抽象类
2.抽象类不能用new创建对象,因为调用抽象方法没意义。
3.抽象类中的方法被使用,必须由子类复写所有的抽象方法后,建立子类对象调用。

抽象类和一般类的区别

抽象类练习
假如我们在开发一个系统时需要对员工进行建模,员工包含3个属性(姓名、工号、工资)。
经理也是员工,除了含有员工的属性外,另外还有一个奖金属性。请使用继承的思想设计
出员工类和经理类。要求类中提供必要的方法进行属性访问。

class Employee
{
    private String name = "";
    private String employeeId = "";
    private double pay = -1;

    Employee(String name, String employeeId,double pay)
    {
        this.name = name;
        this.employeeId = emoloyeeId;
        this.pay = pay;
    }

public abstract void work();
} class ManagerEmployee extends Employee { private double bonus = -1; ManagerEmployee(String name, String employeeId,double pay,double bonus) { super(name,emoloyeeId,pay); this.bonus = bonus; } public void work() { System.out.printle("Do Manager Work"); } } class ProfessionalEmployee extends Employee { ProfessionalEmployee(String name, String employeeId,double pay) { super(name,emoloyeeId,pay); } public void work() { System.out.printle("Do Professional Work"); } }

 


/**
模板方法设计模式

在定义功能室,功能的一部分是确定的,但是有一部分是不确定的。
而确定的部分在使用不确定的部分。解决这个问题可以使用模块方法
设计模式

将不确定的部分暴露出去,由该类的子类去完成
*/

abstract class GetTime
    {
    public final void getTime()
    {
    long statTiem = System.currentTimeMillis();    
    runcode();
    long endTiem = System.currentTimeMillis();

    System.out.println("该程序使用了"+(endTiem-statTiem)+"毫秒");
}

    public abstract void runcode();

    }

class SubTiem extends GetTime
    {
    public vodi runcode()
    {
        for (int x=0;x<10000 ;x++ )
        {
        System.out.print(X);
        }
    }
}

 

5.接口

接口:可以认为接口是特殊的抽象类。当抽象类中方法都是抽象的,那个可以通过接口的形式来完成。
接口的出现将"多继承"通过另外一种新式体现出来。

class 用于定义类
interface 用于定义接口
implements 用于引用接口
extends 用于继承父类

接口的定义是,格式特点
1.接口中常见定义:常量,抽象方法。
2.接口中的成员都有固定修饰符
常量:public static final
方法: public abstract

接口中的成员都是public的,因为接口就是对外暴露原则的。
接口不可被创建对象,因为有抽象方法。
需要被子类实现后才可以实例化。

接口可以被多个实现

class A extends B implements InterA,InterB
{

}

接口可以被接口继承

interface InterA 
{
  void methodA();
}

interface InterB extends InterB 
{
  void methodA();
}

 

abstract class Student
{
    abstract void study();
    void sleep()
    {
        System.out.println("sleep");
    }
}
interface Smoking
{
    void smoke();
}

class ZhangSan extends Student implements Smoking
{
    void study(){}
    public void smoke(){}
}

class Lisi extends Student
{
    void study(){}
}

//张三抽烟,李四不抽烟,他们都是学生

6.多态:可以理解为事物存在的多种形态

 6.1多态的体现:
  父类的引用指向了自己的子类对象
  父类的引用也可以接收自己的子类对象
 6.2多态的前提:
  类于类之间有关系,要么继承,要么实现
  还有一个前提:存在覆盖关系
 6.3多态的好处:
  提高程序扩展性
   6.4多态的弊端:
  只能使用父类的引用访问父类的成员
   6.5多态的转型
  Animal a = new Animal();
  Cat c = (Cat)a; //错误

  Animal a1 = new Cat(); //这是向上转型
  Cat a2 = (Cat)a1; //可行 , 这是向下转型
  6.6多态中成员函数的特点:

  在编译时期:参阅引用类型变量所属的类是否含有调用的方法,如果有,编译通过,如果没有就编译失败

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

  总的来说:就是成员函数在多态调用时,编译看左边,运行看右边。

  6.7多态中成员变量的特点
  无论编译和运行,都参考左边

  6.8在多态中,静态成员函数的特点:
  无论编译和运行,都参考左边

 

7.内部类

class Inner
{

}

内部类的访问规则:
1、内部类可以直接访问外部类中的成员,包括私有.
原因是内部类中持有外部类的引用: 外部类名.this
2、外部类要访问内部类,必须建立对象

访问格式:
1.当内部类定义在外部类的成员位置上,而且非私有化时
可以再外部其他类中直接建立内部类对象
格式如下:
外部类名.内部类名 变量名 = 外部类对象.内部类对象
Outer.Inner in = new Outer().new Inner();

2.当内部类在成员位置上,就可以被成员修饰符所修饰。
比如:private,将内部类在外部类中进行封装
static ,内部类具备静态属性,只能直接访问外部类中的静态成员。出现了访问局限
在外部其他类中,直接访问static内部类的非静态成员格式如下
new Outer.Inner().function();

在外部其他类中,直接访问static内部类的静态成员格式如下
Outer.Inner().function();

注意:当内部类中定义了静态成员,该内部类必须是static的
当外部类中的静态方法访问内部类时,内部类也必须是static的

当描述事物时,事物的内部还有事物,该事物用内部类来描述,
因为内部事务在使用外部事物对的内容。

内部类定义在局部时
1.不可以被成员修饰符修饰
2.可以直接访问外部类中的成员,因为还有特有的外部中的引用。
但是不额可以王文它所在的局部中的变量,只能访问被final修饰的局部变量。

Java学习-第三天

标签:blog   io   使用   ar   java   for   数据   sp   div   

原文地址:http://www.cnblogs.com/lhy_2011/p/4020218.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!