写在开头

包、类、接口、方法、变量、参数、代码块,这些都是构成Java程序的核心部分,即便最简单的一段代码里都至少要包含里面的三四个内容,这两天花点时间梳理了一下,理解又深刻了几分。

Java中的包

Java 定义了一种名字空间,称之为包:package。一个类总是属于某个包,类名(比如Person)只是一个简写,真正的完整类名是包名.类名,这才是唯一确定一个类路径的写法,不同包中的类名允许重复。
包名推荐使用倒置的域名,例如org.apache

包的定义

//包名
package hello;

public class Person {
    // 包作用域:
    public void hello() {
        System.out.println("Hello!");
    }
}

包的作用域

通过访问修饰符,可以确认类中方法与属性相对于包的作用域,这在前面的文章中已经提过了,不再赘言,直接贴图。

Java中包的引入通过import关键字实现,在写import的时候,可以使用*,表示把这个包下面的所有class都导入进来(但不包括子包的class):

import java.util.ArrayList;
public class test {
    public static void main(String[] args) {
        ArrayList<Object> objects = new ArrayList<>();
    }
}

当然处理import导入外,也可以通过完成的包名.类名的方式进行引入,但太麻烦了,很少用到。

Java中的类

Java中有个从1995年就喊出的口号“一切皆对象”,而对象在程序中的具象就是通过类(class)来实现!

类的创建

比如有这样一个Person对象,拥有姓名,性别,年龄等特性,行为方式有吃饭,睡觉和跑步,那我们就可以在Java中如下定义:

public class Person {
	//姓名
    private String name;
    //年龄
    private int age;
    //性别
    private int sex;
	/**
	* 吃饭
	*/
    private void eat() {
    }
	/**
	* 睡觉
	*/
    private void sleep() {
    }
	/**
	* 跑步
	*/
    private void run() {
    }
}

类创建好了,如何用呢?这时候需要通过new关键字去创建一个类对应的对象
Person person = new Person();

类的初始化赋值

这行代码创建了一个Person对象,并在堆内存中分配一定的空间,person被称为对象Person的引用,通过这个引用可以对对象进行初始化赋值操作

通过引用变量赋值
示例代码:

public class Person {
    private String name;
    private int age;
    private int sex;

    public static void main(String[] args) {
        Person person = new Person();
        person.name = "JavaBuild";
        person.age = 18;
        person.sex = 1;
        
        System.out.println(person.name);
        System.out.println(person.age);
        System.out.println(person.sex);
    }
}

通过构造方法赋值
示例代码:

public class Person {
    private String name;
    private int age;
    private int sex;

    public Person(String name, int age, int sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public static void main(String[] args) {
        Person person = new Person("JavaBuild", 18, 1);

        System.out.println(person.name);
        System.out.println(person.age);
        System.out.println(person.sex);
    }
}

内部类

根据上面的内容,我们已经熟悉了Java中的类,实际上在类的内部依旧可以创建一个类,这样的类就被称之为:
内部类
,内部类根据创建的位置,关键字等修饰符分为如下几类:

1、成员内部类

编译之后会生成两个class文件:OuterClass.class和OuterClass$InnerClass.class

class OuterClass {
    class InnerClass {} //成员内部类
}

2、方法内部类

编译之后会生成两个class文件:OuterClass.class和OuterClass$1InnerClass.class
只能在定义该内部类的方法内实例化,方法内部类对象不能使用该内部类所在方法的非final局部变量
当一个方法结束,其栈结构被删除,局部变量成为历史。但该方法结束后,在方法内创建的内部类对象可能仍然存在于堆中

class OuterClass {
    public void doSomething(){
        class Inner{
        }
    }
}

3、匿名内部类

编译后生成两个class文件:Fish.class和Fish$1.class

public class Fish {
    /**
     * 游泳方法
     */
    public void swim() {
        System.out.println("我在游泳!");
    }

    public static void main(String[] args) {
        //创建鱼对象
        Fish fish = new Fish() {
            //重写swim方法
            public void swim() {
                System.out.println("我在游泳,突然发生海啸,我撤了!");
            }
        };
        
        fish.swim();
    }
}

4、静态内部类

静态嵌套类,并没有对实例的共享关系,仅仅是代码块在外部类内部
静态的含义是该内部类可以像其他静态成员一样,没有外部类对象时,也能够访问它
静态嵌套类仅能访问外部类的静态成员和方法
在静态方法中定义的内部类也是静态嵌套类,这时候不能在类前面加static关键字

class OuterFish {
    static class InnerFish {
    }
}

class TestStaticFish { 
    public static void main(String[] args) {
        //创建静态内部类对象
        OuterFish.InnerFish iFish = new OuterFish.InnerFish();
    }
}

内部类的特点

1、内部类提供了某种进入其继承的类或实现的接口的窗口
2、与外部类无关,独立继承其他类或实现接口
3、内部类提供了Java的"多重继承"的解决方案,弥补了Java类是单继承的不足
4、内部类仍然是一个独立的类,在编译之后内部类会被编译成独立的.class文件,但是前面冠以外部类的类名和$符号
5、内部类不能用普通的方式访问。内部类是外部类的一个成员,因此内部类可以自由地访问外部类的成员变量,无论是否是private的
6、内部类声明成静态的,就不能随便的访问外部类的成员变量了,此时内部类只能访问外部类的静态成员变量

Java中的接口

在讲OOP时,我们提到过面向对象的四大特性,其中抽象就是那个第四大特性,而抽象的体现在Java中主要为抽象类和接口!
接口是通过interface 关键字修饰的,用来对一类具有共性对象的一种抽象,通过不同的类进行实现,来满足各自需求。

接口的特性

1、接口中允许定义变量
2、接口中允许定义抽象方法
3、接口中允许定义静态方法(Java 8 之后)
4、接口中允许定义默认方法(Java 8 之后)
5、接口不允许直接实例化
6、接口可以是空的
7、不要在定义接口的时候使用 final 关键字
8、接口的抽象方法不能是 private、protected 或者 final
9、接口的变量是隐式 public static final(常量)

接口的典型案例

我们在之前聊到对象的浅拷贝与深拷贝时提到过Cloneable接口,这就是一个典型的接口应用案例,Cloneable 和 Serializable 一样,都属于标记型接口,它们内部都是空的。实现了 Cloneable 接口的类可以使用 Object.clone() 方法,否则会抛出 CloneNotSupportedException。

接口与抽象类的区别

1、抽象类可以有构造方法;接口中不能有构造方法(因为不允许直接实例化)。
2、抽象类中可以有普通成员变量;接口中没有普通成员变量。
3、抽象类中可以包含非抽象普通方法;JDK1.8 以前接口中的所有方法默认都是抽象的,JDK1.8 开始方法可以有 default 实现和 static 方法。
4、抽象类中的抽象方法的访问权限可以是 public、protected 和 default;接口中的抽象方法只能是 public 类型的,并且默认即为 public abstract 类型。
5、抽象类中可以包含静态方法;JDK1.8 前接口中不能包含静态方法,JDK1.8 及以后可以包含已实现的静态方法。
6、抽象类和接口中都可以包含静态成员变量,抽象类中的静态成员变量可以是任意访问权限;接口中变量默认且只能是 public static final 类型。
7、一个类可以实现多个接口,用逗号隔开,但只能继承一个抽象类。
接口不可以实现接口,但可以继承接口,并且可以继承多个接口,用逗号隔开。

未完待续......

标签: none

添加新评论