黑马程序员—面向对象（下）

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

面向对象:

 

 

抽象类：

概述：用abstract 关键字修饰的类（当多个类中出现相同功能，但是功能主体不同，这时可以进行向上抽取；只抽取功能定义，而不抽取功能主体。）

 

抽象类的特点

A:抽象类和抽象方法必须使用abstract修饰

B:抽象类不能被实例化

C:抽象类有构造方法，用于子类实例化使用

D:如果一个类是抽象类，那么，继承它的子类

要么是抽象类。

要么重写所有抽象方法。

抽象类的成员特点

A:成员变量 --可以变量，也可以是常量

B:构造方法 --有构造方法

C:成员方法 --可以有抽象方法，也可以有非抽象方法（全是抽象方法或者非抽象方法都是可以的） 

abstract不能和哪些关键字共存？

Final  private   static

补充:

抽象类和一般类：

相同点：抽象类和一般类都是用来描述事物的，都在内部定义了成员。 

不同点： 

1）一般类有足够的信息描述事物；而抽象类描述事物的信息有可能不足。 

2)一般类中不能定义抽象方法，只能定义非抽象方法.而抽象类中可定义抽象方法，同时也可以定义非抽象方法。 

3）一般类可以被实例化；而抽象类不可以被实例化。 

 

代码示例：

abstract class Student
{
abstract final void study();
//abstract void study1();
void sleep()
{
System.out.println("躺着");
}
}
/*

class ChongCiStudent extends Student
{
void study()
{
System.out.println("chongci study");
}
}

class BaseStudent extends Student
{
void study()
{
System.out.println("base study");
}
}

class AdvStudent extends Student
{
void study()
{
System.out.println("adv study");
}
}
*/
class AbstractDemo
{
public static void main(String[] args)
{
//new Student();
//new BaseStudent().study();
}
}

 

 

接口

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

格式： interface接口名{} 

 

如何定义一个接口？用interface 关键字声明。

定义好了一个接口，如何去使用这个接口？用implements 关键字实现接口中所有的方法。

代码示例：

interface Inter
{
public static final int NUM = 3;
public abstract void show();
}

interface InterA
{
public abstract void show();
}

class Demo
{
public void function(){}
}

class Test extends Demo implements Inter,InterA
{
public void show(){}
}

interface A
{
void methodA();
}
interface B //extends A
{
void methodB();
}

interface C extends B,A
{
void methodC();
}

class D implements C
{
public void methodA(){}
public void methodC(){}
public void methodB(){}
}

class InterfaceDemo
{
public static void main(String[] args)
{
Test t = new Test();
System.out.println(t.NUM);
System.out.println(Test.NUM);
System.out.println(Inter.NUM);

}
}

 

 

补充：

implements（ 实现 )

*  注意：接口不可以实例化；只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化：否则这个子类也是抽象类。 

*  在Java中不直接支持多继承，因为会出现调用的不确定性。 所以Java将多继承机制进行改良，在Java中变成了多实现。 

*一个类可以实现多个接口。 

      接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。 

      接口的出现避免了单继承的局限性。

 

注意：加abstract 的情况接口可以不被多实现。

 

接口的特点：

A:接口不能被实例化。

B:一个类如果实现了接口：

要么是抽象类。要么实现接口中的所有方法。

 

接口的成员特点：

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

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

推荐：永远手动给出修饰符。

接口的思想特点：

A:对外暴露的规则

B:是功能的扩展

C:降低耦合度

耦合：类与类的关系

内聚：类自己完成某件事情的能力接口上的成员有哪些特点？

类，接口的关系

A:类与类

继承关系,只能单继承，可以多层继承。

B:类与接口

实现关系，可以单实现，也可以多实现。

还可以在继承一个类的同时实现多个接口。

C:接口与接口

继承关系，可以单继承，也可以多继承。

抽象类和接口的区别？

相同点：都是不断向上抽取而来的。 

不同点： 

1，抽象类需要被继承，而且只能单继承。接口需要被实现，而且可以多实现。 

2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。 

注意：接口中只能定义抽象方法，必须由子类去实现。 

3，抽象类的继承，是is a关系，在定义该体系的基本共性内容。接口的实现是like a关系。

 

代码示例练习：

/*
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
{
}

abstract class Sporter
{
abstract void play();
}
interface Study
{
}
class wangwu extends Sport implements Study
{
}
*/

class
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}

 

 

包 package

一．概念：

1*对类文件进行分类管理 

2*给类提供多层命名空间 

3*写在程序的第一行 

4*类名的全称是 包名.类名 

5*包也是一种封装形式 

二．格式：Package pack;//定义一个包（package 包名）

注意: Java中定义包是的规则是字母都是小写//package com.itcast.pack.demo

 

类的全名称是:包名.类名

 

    编译命令：javac –d 位置（.当前路径） java源文件 

 

包是一种封装形式，用于封装类，想要被包以外的程序访问，该类必须用public修饰

 

 

三．包与包之间访问:

*需要设置classpath告诉Jvm去哪里找指定的package包

*包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰
*不同包中的子类还可以直接访问父类中被protected（被保护的）权限修饰的成员
*包与包之间可以使用的权限只有两种，public protected

                            public     p
ca59
rotected     default     private
     同一个类中      ok              ok            ok            ok
     同一个包中      ok              ok            ok
     子类             ok          ok
     不同包中         ok 

 

推荐：

成员变量 private

构造方法 public

成员方法 public

 

四．不同修饰符修饰的内容(掌握 和内部类无关)

类 成员变量 成员方法 构造方法

private Y Y Y

默认 Y Y Y Y

protected Y Y Y

public Y Y Y Y

abstract Y Y

static Y Y

final Y Y Y

 

注意，常见规则如下：

以后，所有的类都用public修饰。并且，在一个java文件中，只写一个类。

 

以后，所有的成员变量用private修饰。

 

以后，所有的成员方法用public修饰。

如果是抽象类或者接口：

public abstract + ...

 

以后，所有的构造方法用public修饰。

如果类是工具类或者单例类：

构造用private修饰

 

 

 

 

 

import 关键字： 

当我们用到某个包中的类的时候，就用关键字import把包的所有的类导入进行。 

 

内部类

1.概述：将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。 

简单的说就是类中还有一个类，就是内部类。 

字节码文件名：外部类名$内部类名.class 

 

2.内部类访问特点： 

l 内部类可以直接访问外部类中的成员，包括私有成员。 

l 而外部类要访问内部类中的成员必须要建立内部类的对象。 

 

3.一般用于类的设计。 

分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容。 

这时就是还有的事物定义成内部类来描述。 

直接访问外部类中的内部类中的成员。 

 

4.格式：

外部类名.内部类名 = new 外部类对象.new 内部类对象; 

Outer.Innerin = new Outer().new Inner(); 

in.method(); 

如果内部类是静态的。 相当于一个外部类 

外部类名.内部类名 = new 外部类对象.内部类; 

Outer.Inner in = new Outer.Inner(); 

in.method(); 

如果内部类是静态的，成员是静态的。 

外部类名.内部类名.静态函数名; 

Outer.Inner.function(); 

 

注：如果内部类中定义了静态成员，该内部类也必须是静态的。

代码示例：

class Outer
{
private int x = 3;

class Inner//内部类
{
//int x = 4;
void function()
{
//int x = 6;
System.out.println("innner :"+Outer.this.x);//输出6，直接X；输出4，this.x；输出3，Outer.this.x
}
}

/**/
void method()
{
Inner in = new Inner();
in.function();
}
}

class InnerClassDemo
{
public static void main(String[] args)
{
Outer out = new Outer();
out.method();

//直接访问内部类中的成员。
// Outer.Inner in = new Outer().new Inner();
// in.function();
}
}

 

 

5.为什么内部类能直接访问外部类中成员呢？ 

因为内部类持有了外部类的引用。  外部类名.this 

内部类可以存放在局部位置上。（也就是定义在外部类的成员函数里面，主函数也是函数）

内部类在局部位置上只能访问局部中被final修饰的局部变量。 

 

补充：

静态内部类+内部类定义规则

/*

1,当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。

可以直接建立内部类对象。

访问格式：

外部类名.内部类名  变量名 = 外部类对象.内部类对象;

Outer.Inner in = new Outer().new Inner();

 

2,当内部类在成员位置上，就可以被成员修饰符所修饰。

比如，private：将内部类在外部类中进行封装。

static:内部类就具备static的特性。

当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。

 

在外部其他类中，如何直接访问static内部类的非静态成员呢？

new Outer.Inner().function();

 

在外部其他类中，如何直接访问static内部类的静态成员呢？

outer.Inner.function();

 

注意：当内部类中定义了静态成员，该内部类必须是static的。

  当外部类中的静态方法访问内部类时，内部类也必须是static的。

 

当描述事物（类）时，事物的内部还有事物，该事物用内部类来描述。

因为内部事务在使用外部事物的内容。

如：

class Dome

{

private class Lisi

{

 

}

 

public void show()

{

new  Lisi().

}

}

 

*/

class Outer

{

private static  int x = 3;

 

static class Inner//静态内部类

{

static void function()

{

System.out.println("innner :"+x);

}

}

 

static class Inner2

{

void show()

{

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

}

}

 

public static void method()

{

//Inner.function();

new Inner2().show();

}

 

}

 

class  InnerClassDemo2

{

public static void main(String[] args) 

{

Outer.method();

//Outer.Inner.function();

//new Outer.Inner().function();

//直接访问内部类中的成员。

// Outer.Inner in = new Outer().new Inner();

// in.function();

}

}

/*

 

 

内部类定义在局部时

内部类定义在外部类中的某个方法中，创建了这个类型的对象时，且仅使用了一次，那么可在这个方法中定义局部类。

特点：

1，不可以被成员修饰符修饰(Static,private)

2，可以直接访问外部类中的成员，因为还持有外部类中的引用。

但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。(生命周期不同)

*/

class Outer
{
int x = 3;

void method(final int a)
{
final int y = 4;
int yy = 888;
class Inner
{
void function()
{
System.out.println(y);
System.out.println(a);
//System.out.println(yy);不能访问方法中的局部变量，需要用final修饰
}
}
//只能在局部方法中创建局部内部类对象
Inner in= new Inner();
in.function();
}
}

class test3
{
public static void main(String[] args)
{
Outer out = new Outer();
out.method(7);//运行局部成员函数，运行完出栈
out.method(8);
}

 

 

 

匿名内部类：（匿名子类对象）  

其实匿名内部类就是一个匿名子类对象，而且这个对象有点胖，也可以理解为，带内容的对象。  

1.概述：是定义在局部位置的没有名字的内部类。

2:前提：内部类必须是继承一个类或者实现接口。

3:格式:new 父类或者接口(){定义子类的内容}

 

4:使用

当你看到方法的形式参数是接口或者抽象类的时候。用匿名内部类改进

代码示例：

abstract class AbstractDemo
{
abstract void show();
}

class Outer
{
int x = 3;

/*
class Inner extends AbstractDemo
{
int num = 90;
void show()
{
System.out.println("show :"+num);
}
void abc()
{
System.out.println("hehe");
}
}
*/

public void function()
{
//AbstractDemo a = new Inner();
// Inner in = new Inner();
// in.show();
// in.abc();

AbsDemo d = new AbsDemo()
{
int num = 9;
void show()
{
System.out.println("num==="+num);
}
void abc()
{
System.out.println("haha");
}
};

d.show();
//d.abc();//编译失败;

}
}

class InnerClassDemo4
{
public static void main(String[] args)
{
new Outer().function();
}
}

 

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！
-------