目录
(原创文章,转载请注明出处)
博主是计算机专业大学生,不定期更新原创优质文章,感兴趣的小伙伴可以关注博主主页支持一下,您的每一个点赞、收藏和关注都是对博主最大的支持!
一、构造方法
1.1 概念
- 构造方法是一种特殊的方法,在创建对象(通过new关键字)时被自动调用。
- 构造方法的名称与类名完全相同,并且没有返回类型(即使它是void也不行)。
- 在Java中,一个类可以有多个构造方法,可以有不同的参数列表以满足不同的对象创建需求。
1.2 作用
- 对象的创建和初始化:构造方法用于创建对象并初始化对象的状态
- 属性的赋值:构造方法可以接受参数,并使用这些参数来完成对对象属性的赋值
1.3 代码
(1)无参构造
① 例子类
public class Example {
// 无参构造
public Example() {
System.out.println("自动调用了无参构造");
}
}
② 测试类
public class ExampleTest {
public static void main(String[] args) {
new Example();
// 输出:自动调用了无参构造
}
}
(2)含参构造
① 学生类
public class Student {
String name;
Integer age;
// 含参构造
public Student(String name, Integer age) {
this.name = name;
this.age = age;
System.out.println("自动调用了含参构造");
System.out.println("姓名:" + this.name + ",年龄:" + this.age);
}
}
② 测试类
public class StudentTest {
public static void main(String[] args) {
new Student("张三", 22);
// 输出:
// 自动调用了含参构造
// 姓名:张三,年龄:22
}
}
二、抽象
2.1 概念
(1)抽象类
- 在Java中,使用abstract关键字定义的类称为抽象类。
- 抽象类是一个不能被实例化的类。它只能被继承。抽象类中可以包含普通方法的定义和实现,也可以包含抽象方法的定义。
(2)抽象方法
- 在Java中,使用abstract关键字定义的方法称为抽象方法。
- 抽象方法是一种没有实现的方法,需要在继承的子类中进行具体实现。如果一个类包含抽象方法,那么该类必须被声明为抽象类。
2.2 作用
- 代码复用:把相同的代码抽抽取到父类(抽象类),实现了多态性并提高代码的灵活性
- 强制重写:让继承抽象类的子类强制重写父类中的方法,或者说防止子类遗忘重写
2.3 注意
- 抽象类中不一定有抽象方法,有抽象方法的类一定是抽象类
- 抽象类不能实例化;但抽象类中可以有构造方法(用于给属性赋值)
- 抽象类的子类,要么重写抽象类中的所有抽象方法,要么是抽象类
2.4 代码
① 父类
// 抽象类
public abstract class Father {
// 成员变量
private String name;
// 抽象方法
public abstract String say();
// 构造方法
public Father(String name) {
this.name = name;
}
// 实例方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
② 子类
public class Child extends Father {
// 强制实现父类构造方法
public Child(String name) {
super(name);
}
// 强制实现父类抽象方法
@Override
public String say() {
return this.getName() + "实现了父类构造方法";
}
}
③ 测试类
public class Test {
public static void main(String[] args) {
Child child = new Child("子类");
System.out.println(child.say());
// 输出:子类实现了父类构造方法
}
}
三、接口
3.1 概念
- 接口是一种抽象数据类型,定义了一组方法的契约。
- 接口使用interface关键字定义,强调类型的抽象和行为的规范。
- 接口包含全局变量和抽象方法(JDK8之前不能包含普通方法,JDK8重新定义接口,可包含默认方法和静态方法(也叫类方法)。
接口定义如下:
public interface MyInterface {
// 全局常量(Fields)
String NAME = "全局常量";
// 抽象方法(Abstract Methods)
String abstractMethods();
// 默认方法(Default Methods)
default String defaultMethods() {
return "默认方法";
}
// 静态方法(Static Methods)
static String staticMethods() {
return "静态方法";
}
// 嵌套类型(Nested Types)
/* 嵌套的接口、类或枚举 */
}
说明:
- 接口中的全局常量默认使用“public static final”进行修饰,修饰符可省
- 接口中的抽象方法默认使用“public abstract”进行修饰,修饰符可省
- 接口中的默认方法使用“default”修饰, 允许有方法体
- 接口中的静态方法使用“static”修饰, 允许有方法体
3.2 作用
- 接口是对方法进行抽象处理的规则,具有安全性,规范性,可维护性。
- 接口的引入主要是为了实现多重继承的效果,以及定义行为的规范,使得不同的类可以共享相同的行为定义。
3.3 注意
- 接口的子类(实现类),要么重写接口中的所有抽象方法,要么是抽象类。
- 接口不能实例化;接口和类之间是实现关系,通过implements实现接口。
- 使用接口的目的是为了克服单继承的限制,一个类只能有一个父类,而一个接口可以同时继承多个父接口。
- 与抽象类不同,接口不能有构造方法,也不能有实例变量(只能有静态常量)。
3.4 语法
(1)子接口可继承多个父接口
修饰符 interface 子接口 extends 父接口1,父接口2,... { ... }
(2)类通过implements实现接口
修饰符 class 类名 implements 接口1,接口2,...{ ... }
(3)子类继承父类并实现接口
修饰符 class 子类 extends 父类 implements 接口1,接口2,...{ ... }
3.5 代码
① 接口
public interface MyInterface {
// 全局常量(Fields)
String NAME = "全局常量";
// 抽象方法(Abstract Methods)
String abstractMethods();
// 默认方法(Default Methods)
default String defaultMethods() {
return "默认方法";
}
// 静态方法(Static Methods)
static String staticMethods() {
return "静态方法";
}
}
② 父类
public abstract class Father {
abstract String say();
}
③ 子类
public class Child extends Father implements MyInterface {
@Override
public String abstractMethods() {
return "强制重写接口抽象方法";
}
@Override
public String defaultMethods() {
return "强制重写接口默认方法";
}
@Override
String say() {
return "强制重写父类抽象方法";
}
}
④ 测试类
public class InterfaceTest {
public static void main(String[] args) {
Child child = new Child();
System.out.println(child.NAME);
System.out.println(child.abstractMethods());
System.out.println(child.defaultMethods());
System.out.println(child.say());
// 输出:
// 全局常量
// 强制重写接口抽象方法
// 强制重写接口默认方法
// 强制重写父类抽象方法
}
}
四、内部类
4.1 成员内部类
(1)概念:在一个类中定义的类被称为成员内部类
(2)功能:成员内部类可以访问外部类的所有成员(包括属性和方法)
(3)语法:
//实例化成员内部类对象语法格式
外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
(4)代码:
① 成员内部类
class Outer {
String outerAttribute = "外部类成员属性";
String outerMethod() {
return "外部类成员方法";
}
// 定义成员内部类并使用成员方法和属性
class Inner {
String getOuterAttribute() {
return outerAttribute;
}
String getOuterMethod() {
return outerMethod();
}
}
}
② 测试类
public class InnerTest {
public static void main(String[] args) {
Outer.Inner inner = new Outer().new Inner();
System.out.println(inner.getOuterAttribute());
System.out.println(inner.getOuterMethod());
// 输出:
// 外部类成员属性
// 外部类成员方法
}
}
4.2 局部内部类
(1)概念:在方法中定义的类被称为局部内部类(也称方法内部类)
(2)功能:局部内部类可以访问外部类的所有成员(包括属性和方法),但局部内部类中变量和方法却只能在所属方法中访问
(3)代码
import org.junit.Test;
public class Outer {
String outerAttribute = "外部类成员属性";
String outerMethod() {
return "外部类成员方法";
}
// 单元测试
@Test
public void show() {
// 定义局部内部类并使用成员方法和属性
class Inner {
String getOuterAttribute() {
return outerAttribute;
}
String getOuterMethod() {
return outerMethod();
}
}
// 注意:局部内部类只能在外部类的方法中创建对象并使用
Inner inner = new Inner();
System.out.println(inner.getOuterAttribute());
System.out.println(inner.getOuterMethod());
// 输出:
// 外部类成员属性
// 外部类成员方法
}
}
4.3 静态内部类
(1)概念:使用static关键字修饰的成员内部类称为静态内部类
(2)功能:静态内部类只能访问外部类的静态成员(包括属性和方法)
(3)语法:
//实例化静态内部类对象语法格式
外部类.内部类 变量名 = new 外部类.内部类();
(4)代码
① 静态内部类
public class Outer {
static String outerAttribute = "外部类成员属性";
static String outerMethod() {
return "外部类成员方法";
}
// 定义静态内部类并使用成员方法和属性
static class Inner {
String getOuterAttribute() {
return outerAttribute;
}
String getOuterMethod() {
return outerMethod();
}
}
}
② 测试类
public class InnerTest {
public static void main(String[] args) {
Outer.Inner inner = new Outer.Inner();
System.out.println(inner.getOuterAttribute());
System.out.println(inner.getOuterMethod());
// 输出:
// 外部类成员属性
// 外部类成员方法
}
}
4.4 匿名内部类
(1)概念:没有名称的内部类称为匿名内部类,为一个表达式,非常规的类
(2)功能:可以通过匿名对象重写方法,不用再进行实例化对象,可节省代码
(3)语法:
new 父类/接口(参数){
@Override
重写父类/接口方法
}
可以简单理解为:匿名内部类本质上是一个没有名字的子类对象、或者接口的实现类对象
(4)代码:
① 父类
public abstract class Father {
public abstract void show();
}
② 测试类
public class AnonymityInnerTest {
public static void main(String[] args) {
// 这里new的后面部分,其实就是一个Father的子类对象
new Father() {
@Override
public void show() {
System.out.println("重写父类抽象方法");
}
}.show(); // 调用匿名内部类继承父类的方法
// 输出:重写父类抽象方法
}
}
若有不妥之处,恳请读者批评指正