java 中的类_细说java中的类

前言

最近在学习《java编程思想》 学到了内部类

类不就是class吗 天天用 还能讲出花来了不成...

其实不然，在java中，类的种类和使用方式多种多样，花样繁多。其中主要有

普通类

内部类(嵌套类)

匿名类

抽象类

静态类

密封类

就先讲这么多吧。接下来将从应用场景、定义、实例化、这3个方面入手，了解一下关于类的基本常识。

普通类

应用场景

类的由来归根于物以类聚，人以群分。将世间万物相同的特征和行为提取(属性和方法)，归纳总结成一个类型。是我们编程世界最常用也是最基础的单元。

定义

public classcat {publiccat(String _color){this.color=_color;

}//属性

publicString color;//方法(行为)

public voidrun(){

System.out.println(color+"的猫正优雅的向你走来");

}

}

c.run();

这是最基本的类的使用方式。

内部类

应用场景

内部类也叫嵌套类。

可以细分为 非静态内部类、静态内部类,

它的使用场景较为广泛，而且多样

定义

非静态内部类

public classInnerClassTest {privateString name;publicInnerClassTest(String name){this.name=name;

}public classInner{publicString getName(){returnname;

}

}publicInner getInnerClass(){return newInner();

}

}

可以看到我 加粗变色的部分。它定义在一个普通类(外部类)中，它也有自己的属性和方法，它能访问到外部类的成员变量，另外为了方便，一般会在外部中定义一个方法，来对外提供引用，也能够内部使用

实例化

1 InnerClassTest InnerClassTest=new InnerClassTest("张三");2 InnerClassTest.Inner inner=innerClassTest.newInner();3 System.out.println(inner.getName());4 InnerClassTest.Inner s=innerClassTest.getInnerClass();5 System.out.println(s.getName());

可以看到，如果需要访问内部类，首先需要有父类的引用。也就是第一行的外部类实例化

第2行和第4行展示了非静态内部类的2种实例化方式。 一种是.new 内部类 另一种是通过调用外部类中的方法来获取对象

静态内部类

应用场景

静态内部类使用比较少见，参见建造者模式

定义

1 public classInnerClassTest {2 private staticString name;3 publicInnerClassTest(String name){4 name=name;5 }6

7 public staticclassInner{8 public staticString getName(){9 returnname;10 }11 }12 publicInner getInnerClass(){13 return newinner();14 }15 }

实例化

需要注意的是，内部类如果要将方法设置为静态方法，那内部类本身也得是静态的

String name= InnerClassTest.Inner.getName();

由于是静态类，所以不需要实例化外部类，直接外部类点出来就行,不过由于外部类name没有赋值，所以打印出来name是null

匿名类

匿名类被称为匿名内部类 ，也是内部类的一致

使用场景

之所以拿出来单独说，是因为使用场景极其多。简化代码，对于只有一两个小方法的接口来说，不必创建接口文件，优雅不少 先来举个栗子

定义

new DataTemplate().exectue(newIDataManager() {

@Overridepublic voidProcess() {

System.out.println("执行了接口实现方法");

}

});

从变色的部分可以看出，这是个接口，而接口正常情况下是无法new的。在类里面却可以随意使用，只要实现接口的方法即可。

这种使用方式，随处可见

newTimerTask(){

@Overridepublic voidrun() {

}

}

newRunnable(){

@Overridepublic voidrun() {

}

};

是不是很熟悉，做异步任务，定时任务常用到。

newComparator() {

@Overridepublic intcompare(Object o1, Object o2) {return 0;

}

@Overridepublic booleanequals(Object obj) {return false;

}

};

是不是更熟悉了，做排序比较的时候经常用。在java中，匿名类无处不在。

这种简写的方式相当于

public class nimingTest implementsComparator {

@Overridepublic intcompare(Object o1, Object o2) {return 0;

}

}

抽象类

抽象类顾名思义，将共同特征抽象出来，提取共同的行为， 由子类去实现。关键字 abstract

在类中加入abstract 它可以没有抽象方法。相反，一个类中如果有abstract修饰某个方法，它就叫抽象类，而且必须给类加上abstract修饰

使用场景

抽象是软件工程面向对象中很重要的概念，抽象类和接口很相似，同样可以由子类重写实现。不同点在于，接口没有方法体，而抽象类可以正常拥有属性和方法体，可以有自己的普通方法。

例如下单绑定卡，卡类就是个抽象类，子类有银行卡，信用卡，会员卡，积分卡，超市联名卡 。他们都有共同的属性，如卡号，类型，拥有共同的支付行为

常见的有抽象工厂，属于最常见的设计模式，下单业务逻辑也会有见到抽象的身影。不同类型的订单执行不同的子类逻辑(如，普通订单，夺宝，拼团，送礼)

定义

public abstract class nimingTest implementsComparator {

@Overridepublic intcompare(Object o1, Object o2) {return 0;

}

}

这个抽象类可以继承接口，可以不需要抽象方法，不过抽象类无法实例化，因为不是具象，它需要子类继承

public class AbstractChildClassTest extendsnimingTest {

}

实例化

new AbstractChildClassTest().compare(1,2);

此时之类可以访问父类所有的public方法，如果父类有抽象方法，则子类必须要实现这个方法，除非之类也是一个抽象类。

此时给抽象类加一个抽象方法，让子类来继承

public abstract class nimingTest implementsComparator {

@Overridepublic intcompare(Object o1, Object o2) {return 0;

}public abstractString getName();

}

子类

public class AbstractChildClassTest extendsnimingTest {

@OverridepublicString getName() {return null;

}

}

使用

new AbstractChildClassTest().compare(1,2);new AbstractChildClassTest().getName();

还可以绕过之类，自己写匿名类，对付接口的一招也能用于抽象类

newnimingTest() {

@OverridepublicString getName() {return "";

}

};

可以看到，之前不能new的抽象类，居然能跳过被之类继承的环境，直接采用匿名的方式实现抽象方法。

使用的时候

String name= newnimingTest() {

@OverridepublicString getName() {return "xss";

}

}.getName();

System.out.println(name);

静态类

静态类属于比较特殊的存在，因为在整个内存中只有一份元数据。所以不存在实例化的可能，其实静态内部类才算是静态类。

关键字 static

关键字无法修饰类(仅限外部类)，只能用于成员变量和方法。凡是有方法被static修饰的类，我们叫他静态类。

静态变量，静态块，静态方法 静态内部类

使用场景

一般用于工具类或者类似枚举的成员变量比较固定的值的地方

定义

如下代码 展示了 静态变量，静态块，静态方法，静态内部类

public class StaticClassTest {

static {

System.out.println("静态块做初始化工作");

}

public static int count;

public static int getSum(int a,int b){

return a+b;

}

public static class StaticInnerClass{

public void Register(){

System.out.println("唯一注册通道");

}

}

}

实例化

静态相关的 都不需要实例化，内存中仅一份

StaticClassTest.getSum(1,2);

StaticClassTest.count=2;

密封类

密封类也叫最终类。和普通类没有区别，有属性有方法。唯一特性：无法被之类继承

关键字：final

使用场景

创造这个类的人员觉得该类以及没有扩展的必要，也不行任何人扩展它，就会将类 加上final 修饰，使它无法被继承

定义

public final class InnerTestMain {}

实例化

和正常类一样new就好啦。密封类在日常使用中见到的极少，使用场景不太广泛

总结

罗列了一圈下来，才发现，主角是内部类。

算算看，非静态内部类，匿名内部类，静态内部类，抽象内部类，抽象静态内部类。还有lamda表达式，也是用的匿名类。

关于类的知识就讲到这里。