类
类是封装对象的属性和行为的载体,反过来说具有相同属性和行为的一类实体被称为类。
类的定义
- 类是相同或相似对象的一种抽象,是对象的一个模板,它描述一类对象的行为和状态。
- 类是具有相同属性和方法(行为)的对象的集合
属性
是对象具有的特征。每个对象的每个属性都拥有特定值.
Java是面向对象的语言,体现在Java程序都以类class为组织单元,而一个类是对象的抽象,所以类由属性和方法两部分组成。
定义一个类,主要有三个步骤:
1、定义类名,用于区分不同的类。如下代码中 public class 后面跟的就是类名。class是声明类的关键字,类名后面跟上大括号,大括号里面就是类的一些信息。public为权限修饰符。
public class 类名{
//定义属性部分(成员变量)
属性1的类型 属性1;
属性2的类型 属性2;
…
//定义方法部分
方法1;
方法2;
…
}
2、编写类的属性。对象有什么,需要通过属性来表示。属性的定义是写在类名后面的大括号里,在定义属性时,要明确属性的类型。在一个类当中可以写一个或多个属性。当然也可以不定义属性。
3、编写类的方法。方法也是写在大括号里面。可以定义一个方法或多个方法,当然也可以不定义方法。
一个类可以包含以下类型变量:
- 局部变量:在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中,方法结束后,变量就会自动销毁。
- 成员变量:成员变量是定义在类中,方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
- 类变量:也叫静态变量,类变量也声明在类中,方法体之外,但必须声明为 static 类型。
对象
创建对象的方法如下:
类名 对象名 = new 类名();
定义类的时候不会为类开辟内存空间,但是一旦创建了对象,系统就会在内存中为对象开辟一块空间,用来存放对象的属性值和方法。
成员变量就是指的对象的属性,是在类中定义,来描述对象的特性。还有一种变量叫局部变量,它是由类的方法定义,在方法中临时保存数据。
在使用时注意,成员变量可以被本类的所有方法所使用,同时可以被与本类有关的其他类所使用。而局部变量只能在当前的方法中使用。
- 局部变量的作用域仅限于定义它的方法内。而成员变量的作用域在整个类内部都是可见的。
- 同时在相同的方法中,不能有同名的局部变量;在不同的方法中,可以有同名的局部变量。
- 成员变量和局部变量同名时,局部变量具有更高的优先级。
内部类
将一个类的定义放在另一个类的定义内部,这就是内部类。而包含内部类的类被称为外部类。
内部类的主要作用如下:
- 内部类提供了更好的封装,可以把内部类隐藏在外部类之内,不允许同一个包中的其他类访问该类
- 内部类的方法可以直接访问外部类的所有数据,包括私有的数据
- 内部类所实现的功能使用外部类同样可以实现,只是有时使用内部类更方便
- 内部类允许继承多个非接口类型(具体将在以后的内容进行讲解)
注:内部类是一个编译时的概念,一旦编译成功,就会成为完全不同的两类。对于一个名为 outer 的外部类和其内部定义的名为 inner 的内部类。编译完成后出现 outer.class 和 outer$inner.class 两类。所以内部类的成员变量/方法名可以和外部类的相同。
例如:
// People.java
//外部类People
public class People {
private String name = “LiLei”; //外部类的私有属性
//内部类Student
public class Student {
String ID = “20151234”; //内部类的成员属性
//内部类的方法
public void stuInfo(){
System.out.println(“访问外部类中的name:” + name);
System.out.println(“访问内部类中的ID:” + ID);
}
}
//测试成员内部类
public static void main(String[] args) {
People a = new People(); //创建外部类对象,对象名为a
Student b = a.new Student(); //使用外部类对象创建内部类对象,对象名为b
// 或者为 People.Student b = a.new Student();
b.stuInfo(); //调用内部对象的suInfo方法
}
}
成员内部类的使用方法:
- Student 类相当于 People 类的一个成员变量,所以 Student 类可以使用任意访问修饰符
- Student 类在 People 类里,所以访问范围在类里的所有方法均可以访问 People 的属性(即内部类里可以直接访问外部类的方法和属性,反之不行)
- 定义成员内部类后,必须使用外部类对象来创建内部类对象,即
内部类 对象名 = 外部类对象.new 内部类();
- 如果外部类和内部类具有相同的成员变量或方法,内部类默认访问自己的成员变量或方法,如果要访问外部类的成员变量,可以使用 this 关键字 如上述代码中:a.this
注:成员内部类不能含有 static 的变量和方法,因为成员内部类需要先创建了外部类,才能创建它自己的。
静态内部类
静态内部类通常被称为嵌套类。
// People.java
//外部类People
public class People {
private String name = “LiLei”; //外部类的私有属性
/*外部类的静态变量。
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有,而不是某个对象所有,即被类的所有对象所共享。静态成员可以使用类名直接访问,也可以使用对象名进行访问。
*/
static String ID = “510xxx199X0724XXXX”;
//静态内部类Student
public static class Student {
String ID = “20151234”; //内部类的成员属性
//内部类的方法
public void stuInfo(){
System.out.println("访问外部类中的name:" + (new People().name));
System.out.println("访问外部类中的ID:" + People.ID);
System.out.println("访问内部类中的ID:" + ID);
}
}
//测试成员内部类
public static void main(String[] args) {
Student b = new Student(); //直接创建内部类对象,对象名为b
b.stuInfo(); //调用内部对象的suInfo方法
}
}
静态内部类是 static 修饰的内部类,这种内部类的特点是:
- 静态内部类不能直接访问外部类的非静态成员,但可以通过 new 外部类().成员 的方式访问
- 如果外部类的静态成员与内部类的成员名称相同,可通过类名.静态成员访问外部类的静态成员;如果外部类的静态成员与内部类的成员名称不相同,则可通过成员名直接调用外部类的静态成员
- 创建静态内部类的对象时,不需要外部类的对象,可以直接创建 内部类 对象名= new 内部类();
局部内部类
局部内部类,是指内部类定义在方法和作用域内。
// People.java
//外部类People
public class People {
//定义在外部类中的方法内:
public void peopleInfo() {
final String sex = “man”; //外部类方法中的常量
class Student {
String ID = “20151234”; //内部类中的常量
public void print() {
System.out.println("访问外部类的方法中的常量sex:" + sex);
System.out.println(“访问内部类中的变量ID:” + ID);
}
}
Student a = new Student(); //创建方法内部类的对象
a.print();//调用内部类的方法
}
//定义在外部类中的作用域内
public void peopleInfo2(boolean b) {
if(b){
final String sex = "man"; //外部类方法中的常量
class Student {
String ID = "20151234"; //内部类中的常量
public void print() {
System.out.println("访问外部类的方法中的常量sex:" + sex);
System.out.println("访问内部类中的变量ID:" + ID);
}
}
Student a = new Student(); //创建方法内部类的对象
a.print();//调用内部类的方法
}
}
//测试方法内部类
public static void main(String[] args) {
People b = new People(); //创建外部类的对象
System.out.println("定义在方法内:===========");
b.peopleInfo(); //调用外部类的方法
System.out.println("定义在作用域内:===========");
b.peopleInfo2(true);
}
}
局部内部类也像别的类一样进行编译,但只是作用域不同而已,只在该方法或条件的作用域内才能使用,退出这些作用域后无法引用的。
匿名内部类
匿名内部类,顾名思义,就是没有名字的内部类。正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写。但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口。
// Outer.java
public class Outer {
public Inner getInner(final String name, String city) {
return new Inner() {
private String nameStr = name;
public String getName() {
return nameStr;
}
};
}
public static void main(String[] args) {
Outer outer = new Outer();
Inner inner = outer.getInner("Inner", "NewYork");
System.out.println(inner.getName());
}
}
interface Inner {
String getName();
}
匿名内部类是不能加访问修饰符的。要注意的是,new 匿名类,这个类是要先定义的,如果不先定义,编译时会报错该类找不到。
同时,在上面的例子中,当所在的方法的形参需要在内部类里面使用时,该形参必须为final。这里可以看到形参 name 已经定义为 final 了,而形参 city 没有被使用则不用定义为 final。
然而,因为匿名内部类没名字,是用默认的构造函数的,无参数的,如果需要该类有带参数的构造函数,示例如下:
public Inner getInner(final String name, String city) {
return new Inner(name, city) {
private String nameStr = name;
public String getName() {
return nameStr;
}
};
}
注意这里的形参 city,由于它没有被匿名内部类直接使用,而是被抽象类 Inner 的构造函数所使用,所以不必定义为 final。