------- android培训、java培训、期待与您交流! ----------
黑马学习日志之七 抽象类,接口,内部类,包
1 抽象类
1.1抽象类和抽象方法
抽象就是从多个事物中将共性的,本质的内容抽取出来。
抽象类:使用abstract关键字修饰的类就是抽象类。
抽象方法:使用abstract关键字修饰。只有方法的定义,但是没有方法体的方法,该方法的 具体实现由子类完成,包含抽象方法的类需要定义为抽象类。
例子:
abstract class Demo {
public abstract void live();
}
1.2 抽象类的特点
(1)一个类如果有了抽象方法,那么这个类必须是抽象类。
(2)抽象类里边可以没有抽象方法。
(3)抽象类是不能够被实例化的,不能够创建对象的。
(4)如果一个类继承抽象类,它要么重写抽象类中的所有抽象方法,要么本身也是抽象类。
1.3 抽象类的成员特点:
成员变量:子类可以直接继承抽象类中的成员变量。
成员方法:抽象方法在子类中必须要被实现。普通方法可以被子类直接继承使用。
构造方法:抽象类中有构造函数,子类创建对象的时候,调用父类构造函数,为父类中 的成员初始化。
1.4 不可以和abstract共存的关键字:
private私有的,外部直接无法访问。抽象方法是为了让子类重写 一旦加了private,子 类无法重写
static抽象方法就可以可以通过类名调用,但是这样是没有意义的。
final final修饰的方法不能被重写。所以它和abstract冲突。
2 接口
2.1 接口概念
2.1.1接口理解
接口可以认为是一个特殊的抽象类,当抽象类中的方法都是抽象的,那么该类可以通过接口的形式来表示。解决了java中只能单继承的问题。
接口中定义的方法默认是公有的抽象的,被public abstract修饰;接口中定义的变量默认为全局常量,使用public static final修饰
使用abstract修饰的抽象方法在子类中必须实现,而接口在扩展当前类的新功能的时候使用。
定义接口使用interface,实现一个接口使用impentents。
2.1.2接口的特点:
接口是对外暴露规则;
接口是程序的功能扩展;
接口的出现降低了耦合性,使用原则低耦合高内聚;
接口不能直接创建对象,是抽象的,不能实例化;
接口可以用来多实现,类与接口之间是实现关系,可以继承一个类同时实现多个接口。
例子:
interface Person {
public abstract void work();
}
class CarWorker implements Person {
public void workt(){
System.out.println("造汽车");
}
}
class ITWorker implements Person {
public void work(){
System.out.println("敲代码");
}
}
2.2 接口成员特点:
构造函数:接口没有构造函数;
成员方法:只有抽象方法,默认的修饰符:public abstract;
成员变量:只有 final修饰的常量;默认的修饰符:public static final
2.3类、接口的关系
类与类之间的关系:继承关系,java中只支持单继承,不支持多继承,支持多层继承。
类与接口之间的关系:实现关系,java中支持单实现,也支持多实现。
接口与接口之间的关系:继承关系,java中的接口而言,支持单继承,也支持多继承。
注意:在一般情况下,java中只支持单继承,但是接口是一个特列,接口能实现多继承。
例子:
interface Inter1 {
public abstract void show1();
}
interface Inter2 {
public abstract void show2();
}
// 接口可以多继承
interface Inter extends Inter1, Inter2 {
}
abstract class Fu {
//抽象方法
public abstract void show();
//普通方法
public void method(){
System.out.println("Fu method");
}
}
class Zi extends Fu implements Inter1,Inter2 {
//重写父类中所有的抽象方法
public void show(){
System.out.println("Zi show");
}
//重写接口中的抽象方法
public void show1(){
System.out.println("Zi show1");
}
public void show2(){
System.out.println("Zi show2");
}
}
class InterfaceDemo3 {
public static void main(String[] args) {
Zi z = new Zi();
z.method();
z.show();
z.show1();
z.show2();
}
}
2.4接口与抽象类的区别
共性:都是从不同的类中将公共的内容抽取出来,不断抽取出来的抽象概念
区别:
(1)关键字:
接口:interface
抽象类:abstract
(2)关系:
接口:实现关系,可以多实现;
抽象类:继承关系只能单继承。
(3)成员的区别:
接口:
构造函数:没有
成员方法:抽象方法
成员变量:常量
抽象类:
构造函数:有。
成员方法;普通方法,抽象方法
成员变量:普通变量,常量
(4)什么时候使用抽象类,什么时候使用接口
接口:部分子类必须要做的操作,定义在接口中。
抽象类:所有子类都必须要做的操作,定义在抽象类中
3 内部类
3.1 内部类概念
在类里面定义的类称之为内部类,内部类是外部类的一个成员。
例如:
class A{
class B{
}
}
3.2 内部类访问规则
内部类可以直接访问外部类中成员,包括私有。
外部类访问内部类要建立对象。
之所以内部类可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用:外部类名.this
例子:
class Demo {
private int num = 10;
// 内部类
class InnerDemo{
System.out.println(num); // 内部类直接访问外部类
private int num2 = 20;
}
public void method(){
Test t = new Test(); //外部类访问内部类要建立对象
sop(num2);
}
3.3 成员内部类
定义在类中,方法外。
外部类访问内部类格式: 外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
成员内部类用到的修饰符:
private:提高数据的安全性。内部类被私有private修饰的话,不可以访问。
static:静态内部类。
注意:面试中问类可以被private,static修饰吗?可以的 当内部类位于外部类的成 员变量的位置时才可以。
例子:
class Outer {
private int num = 10;
//成员内部类
class Inner {
int num = 20;
public void show(){
int num=30;
System.out.println(num); //30
System.out.println(this.num);// 20
System.out.println(Outer.this.num); //10
}
}
}
class InnerClassDemo2 {
public static void main(String[] args) {
//外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
3.4 静态内部类
就是在成员内部类的基础上加static关键字。
静态内部类访问原则:静态内部类只能访问外部类的静态成员。
外部类访问静态内部类的方法:外部类名.内部类名 对象名 = new 外部类名.内部类名();
Outer.Inner oi = new Outer.Inner();
oi.innerShow();
外部类访问静态内部类的静态方法:Outer.Inner.innerShow();
内部类方法是静态的,内部类不是静态的,不能访问。因为内部类中定义了静态成员,内部类必须是静态的。
外部类的静态方法访问内部类时,内部类必须是静态的。
内部类私有并非静态 内部类方法是非静态 只能用外部类方法访问。
例子:
class Demo8 {
public static void main(String[] args) {
//1.内部类是静态的 内部类中方法非静态,可以用下面方法访问
Outer.Inner oi = new Outer.Inner();
oi.show();
//2.内部类静态的内部类方法也是静态的,可以用下面方法访问
Outer.Inner2.show2();*/
//内部类私有并非静态,内部类方法是非静态,只能用外部类方法访问
Outer o= new Outer();
o.print();
}
}
class Outer {
//内部类是静态的 方法非静态
static class Inner {
public void show() {
System.out.println("Hello World!");
}
}
static class Inner2 {
public static void show2() {
System.out.println("Hello World!2");
}
}
//不要在非静态的内部类中定义静态的方法
/*class Inner3 {
public static void show3() {
System.out.println("Hello World!3");
} }*/
//私有非静态内部类,非私有非静态内部类函数
private class Inner4{
public void show4() {
System.out.println("Hello World!3");
}
}
public void print() {
new Inner4().show4();
}
}
3.5 局部内部类
在外部类成员方法中定义的内部类。
局部内部类特点:
局部内部类不能被定义为static。Static只修饰成员,不修饰局部。
局部内部类不能被成员修饰符修饰,用于修饰局部内部类的只有final和abstract。
方法内部类只能在定义该内部类的方法内实例化,不可以在此方法外对其实例化。
可以直接访问外部类的成员,因为还持有外部类的引用。
3.6 匿名内部类
匿名内部类:没有名字的内部类,是内部类的简化写法。匿名内部类就是一个继承 外部类或者实现接口的子类对象。匿名内部类定义在局部位置。
匿名内部类的前提:继承一个类和接口。
匿名内部类的格式:
new 外部类名或者接口名(){
重写父类或者接口的抽象方法,也可以定义特有方法
};
注意:
匿名内部类就是一个匿名子类对象,带内容的对象;
匿名内部类中定义的方法最多不超过3个。
例子:
interface Inter {
public abstract void show();
public abstract void show2();
}
class Outer {
private int num = 10;
public void method(){
// 匿名内部类
new Inter(){
public void show(){
System.out.println("show");
}
public void show2(){
System.out.println("show2");
}
};
new Inter(){
public void show(){
System.out.println("show");
}
public void show2(){
System.out.println("show2");
}
}.show();
new Inter(){
public void show(){
System.out.println("show");
}
public void show2(){
System.out.println("show2");
}
}.show2();
//调用匿名内部类特有方法
new Inter(){
public void show(){
System.out.println("show");
}
public void show2(){
System.out.println("show2");
}
public void function(){
System.out.println("funciton");
}
}.function();
//匿名内部类就是一个接口或者外部类的子类对象
Inter inter = new Inter(){
public void show(){
System.out.println("show");
}
public void show2(){
System.out.println("show2");
}
};
inter.show();
inter.show2();
}
}
class NiMingInnerClassDemo {
public static void main(String[] args) {
Outer ou = new Outer();
ou.method();
}
}
4 包
4.1 包的概念
包 package
package name;
import 导入 :一个Java源文件只能包含一个package语句,但是可以包含多个import
语句。
import只能导入类,import java.util.*; //导入java.util包中的全部类
导入静态类:import static java.lang.System.*;
4.2 包之间的访问
不同包之间访问: 包名.类名
权限访问修饰符
public | protected | default | private | |
同一类中 | 可以 | 可以 | 可以 | 可以 |
同一包中 | 可以 | 可以 | 可以 | 不可以 |
子类 | 可以 | 可以 | 不可以 | 不可以 |
不同包中 | 可以 | 不可以 | 不可以 | 不可以 |