细说java中的类

Posted 路路-黑客之路

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了细说java中的类相关的知识,希望对你有一定的参考价值。

前言

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

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

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

普通类

内部类(嵌套类)

匿名类

抽象类

静态类

密封类

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

 

普通类

应用场景

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

定义

public class cat {

public cat(String _color){
    this.color=_color;
}
//属性

public String color; 

//方法(行为)

public void run(){

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

}

c.run();

 

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

内部类
应用场景
内部类也叫嵌套类。
可以细分为 非静态内部类、静态内部类,
它的使用场景较为广泛,而且多样
定义

非静态内部类
public class InnerClassTest {
    private String name;
    public InnerClassTest(String name){
        this.name=name;
    }

   public class Inner{
        public String getName(){
            return name;
        }
    }
    public Inner getInnerClass(){
        return new Inner();
    }
}

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

实例化

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

 

可以看到,如果需要访问内部类,首先需要有父类的引用。也就是第一行的外部类实例化
第2行和第4行展示了非静态内部类的2种实例化方式。 一种是.new 内部类 另一种是通过调用外部类中的方法来获取对象


 

静态内部类
应用场景
静态内部类使用比较少见,参见建造者模式
定义
 1 public  class InnerClassTest {
 2     private static String name;
 3     public InnerClassTest(String name){
 4         name=name;
 5     }
 6 
 7    public static class Inner{
 8         public static String getName(){
 9             return name;
10         }
11     }
12     public Inner getInnerClass(){
13         return new inner();
14     }
15 }

 

实例化
需要注意的是,内部类如果要将方法设置为静态方法,那内部类本身也得是静态的
String name= InnerClassTest.Inner.getName();
由于是静态类,所以不需要实例化外部类,直接外部类点出来就行,不过由于外部类name没有赋值,所以打印出来name是null
匿名类
匿名类被称为匿名内部类 ,也是内部类的一致
使用场景
之所以拿出来单独说,是因为使用场景极其多。简化代码,对于只有一两个小方法的接口来说,不必创建接口文件,优雅不少 先来举个栗子

定义
        new DataTemplate().exectue(new IDataManager() {
            @Override
            public void Process() {
                System.out.println("执行了接口实现方法");
            }
        });

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

这种使用方式,随处可见

 new TimerTask(){
           @Override
           public void run() {
               
           }
       }
   new Runnable(){
           @Override
           public void run() {
               
           }
       };

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

    new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return 0;
            }

            @Override
            public boolean equals(Object obj) {
                return false;
            }
        };

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

这种简写的方式相当于

public class nimingTest implements Comparator {

    @Override
    public int compare(Object o1, Object o2) {
        return 0;
    }
}

 抽象类

抽象类顾名思义,将共同特征抽象出来,提取共同的行为, 由子类去实现。关键字 abstract   
在类中加入abstract 它可以没有抽象方法。相反,一个类中如果有abstract修饰某个方法,它就叫抽象类,而且必须给类加上abstract修饰
使用场景
抽象是软件工程面向对象中很重要的概念,抽象类和接口很相似,同样可以由子类重写实现。不同点在于,接口没有方法体,而抽象类可以正常拥有属性和方法体,可以有自己的普通方法。
例如下单绑定卡,卡类就是个抽象类,子类有银行卡,信用卡,会员卡,积分卡,超市联名卡 。他们都有共同的属性,如卡号,类型,拥有共同的支付行为
常见的有抽象工厂,属于最常见的设计模式,下单业务逻辑也会有见到抽象的身影。不同类型的订单执行不同的子类逻辑(如,普通订单,夺宝,拼团,送礼)
定义
public abstract class nimingTest implements Comparator {

    @Override
    public int compare(Object o1, Object o2) {
        return 0;
    }
}

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

public class AbstractChildClassTest extends nimingTest {
}

 

实例化

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

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

 

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

public abstract class nimingTest implements Comparator {

    @Override
    public int compare(Object o1, Object o2) {
        return 0;
    }

    public abstract  String getName();
}

子类

public class AbstractChildClassTest extends nimingTest {
    @Override
    public String getName() {
        return null;
    }
}

使用

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

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

new nimingTest() {
            @Override
            public String getName() {
                return "";
            }
        };

 

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

使用的时候

    String name= new nimingTest() {
            @Override
            public String 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表达式,也是用的匿名类。

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

以上是关于细说java中的类的主要内容,如果未能解决你的问题,请参考以下文章

细说Java中的字符和字符串

java细说 JAVA中 标注 注解(annotation)

如何将 View 类中的代码片段移动到 OnAppearing() 方法?

扩展片段的类中的选项卡

11.按要求编写Java应用程序。 创建一个叫做机动车的类: 属性:车牌号(String),车速(int),载重量(double) 功能:加速(车速自增)减速(车速自减)修改车牌号,查询车的(代码片段

细说OC中的load和initialize方法