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

最新推荐文章于 2024-08-22 20:08:50 发布

奔驰的木马

最新推荐文章于 2024-08-22 20:08:50 发布

阅读量436

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/yjb946928923/article/details/48804793

本文详细介绍了Java中的面向对象、抽象类、接口、包与内部类的概念与应用，包括抽象类的特点、接口的定义与实现、包的作用与访问规则，以及内部类的定义与访问特点。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

------<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     protected     default     private
     同一个类中      ok              ok            ok            ok
     同一个包中      ok              ok            ok
     子类             ok          ok
     不同包中         ok

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

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

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>、期待与您交流！ -------