Java的static，final，代码块，内部类，抽象类，接口等

最新推荐文章于 2023-03-18 19:37:38 发布

Quinto0

最新推荐文章于 2023-03-18 19:37:38 发布

阅读量172

点赞数

分类专栏： java基础语法文章标签：接口类成员 java基础语法

本文链接：https://blog.csdn.net/weixin_43786255/article/details/90813781

版权

java基础语法专栏收录该内容

14 篇文章 1 订阅

订阅专栏

Java的static，final，代码块，内部类，抽象类，接口等

1 static关键字月final关键字

1.1 static

static表示静态。可以修饰属性，方法，代码块内部类等，总结如下：

	特点
修饰属性	①属于类，调用方式：类名.属性； ②属于所有对象的公共属性：对象.属性； ③类变量在类加载的时候就会加载，而且只有一份； ④类变量存储在静态域中； ⑤生命周期比成员变量长。
修饰方法	①在类加载的时候加载； ②调用：类名.方法()； ③static修饰的方法叫静态方法，静态方法只能调用静态成员，不能调用非静态成员；非静态方法可以调用静态方法也可以调用非静态方法； ④在static修饰的方法不能出现this或super关键字。
修饰代码块	①static修饰的代码块叫静态代码块，在类加载的时候自动执行，给类进行初始化，而且只执行一次； ②一个类中可以定义多个静态代码块，按顺序执行； ③静态代码块只能访问类的静态成员，而不允许访问实例成员。
修饰内部类	static修饰内部类。普通类是不允许声明为静态的，只有内部类才可以。被static修饰的内部类可以直接作为一个普通类来使用，而不需先实例一个外部类。

1.2 final

final可以修饰属性，方法，类，总结如下：

	特点
修饰类（final class 类名{}）	表示该类是一个最终类，不能被继承
修饰方法（final 返回值类型方法名()）	表示该方法不能重写
修饰属性（final 属性类型属性名）	表示一个常量，常量一般用大写字母表示

给常量初始化：（1）显示初始化赋值 final 类型变量名 = 值；

（2）静态块 static{}

（3）构造块进行初始化 {}

（4）构造器进行初始化在构造器中赋值

2 代码块

定义：用大括号“｛｝”将多行代码封装在一起，形成一个独立的代码区，这就构成了代码块。

分类如下：

（1）普通代码块：方法的{} / if(){} / 在方法里面{局部代码块}

（2）构造代码块：{} 写在类中，在构造器前执行，创建一次对象就会调用一次（可多次执行）

（3）静态代码块：static{}在类加载时执行，而且只执行一次，会在构造器前执行

（4）同步代码块：在方法 synchronized（锁对象）{}

3 抽象类和抽象方法

概念：用abstract修饰的类就是抽象类（类的修饰符：final/abstract）。

抽象方法：用abstract修饰的方法就是抽象方法

特点：

（1）抽象类不能被实例化（不能直接创建对象），是用来继承的；

（2）抽象类中可以有构造器；

（3）抽象类中可以有抽象方法也可以有非抽象方法；

（4）抽象方法不能具体实现（即没有方法体）；

（5）有抽象方法的类一定是抽象类，抽象类不一定要有抽象方法；

（6）抽象方法必须被继承的子类重写（除非子类也是抽象类，可以不用重写父类的抽象方法；）

（7）final（不能继承的）和abstract（用来继承的）不能同时修饰一个类和类

public  class Test {
	public static void main(String[] args) {
		//Animal a = new Animal();
//		Animal a = new Dog("旺财",5,"公");
//		a.eat();
		Test t = new Test();
		t.manager(new Dog("旺旺",2,"公"));
		
		t.manager(new Cat("猫咪",3));
	}
	public void manager(Animal a) {
		a.eat();
		a.run();
	}
}
abstract class Animal{
	String name;
	int age;
	
	public Animal() {
		super();
	}
	public Animal(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	//吃
	public abstract void eat();
	
	public abstract void run();
//	public void show() {
//		System.out.println();
//	}
	
}
class Dog extends Animal{
	String sex;

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

	@Override
	public void eat() {
		System.out.println("够吃骨头");
	}

	@Override
	public void run() {

	}
	
}
class Cat extends Animal{
	

	public Cat(String name,int age) {
		super(name,age);
	}

	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}

	@Override
	public void run() {
	
	}
	
}

。

（8）abstract与static（静态的），不能同时修饰一个方法。声明static说明可以直接用类名调用该方法；声明abstract说明需要子类重写该方法；如果同时声明static和abstract，用类名调用一个抽象方法肯定不行

4 接口

概念：Java中的接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为(功能)。

定义语法：访问权限修饰符 interface 接口｛｝

特点：

（1）接口也是一个特殊的抽象类(不可以直接实例化)，可以包含常量和抽象方法；

（2）还可以包含静态方法和默认方法（jdk1.8之后的特性）；

（3）接口不可以定义构造器；

（4）实现接口的类必须重写接口的非抽象方法；

（5）类可以实现（implements）多个接口（避免类的单继承不足问题）；

（6）接口是多继承（extends）的。

常量默认[public static final]
public static final int n=10;
  int m = 11;
抽象方法默认：[public abstract]
public abstract void show1();
  void show();


//一下两个为jdk1.8的新特性
//静态方法 
 static void show2() {
	 System.out.println("接口中的静态方法");
 }
 //实现接口子类去重写(对象)
 default void show3() {
	 System.out.println("默认的方法");
 }

作用：接口就是一种实现功能（定义功能_方法），定义规范。

/**
 * @Description 定义USB接口 实现其功能 start() stop();
 * @author refuel
 * @version v1.0
 */
public class Test {
	public static void main(String[] args) {
		//方式1 普通创建电脑对象调用
		Computer1 c = new Computer1();
		c.Work(new CardReader());
		
		//方式2 匿名类的对象
		USB u = new USB() {

			@Override
			public void start() {
				System.out.println("匿名类的对象开始");
			}

			@Override
			public void stop() {
				System.out.println("匿名类的对象结束");
			}
			
		};
		c.Work(u);
		
		//方式3 匿名类的匿名对象
		c.Work(new USB() {

			@Override
			public void start() {
				System.out.println("匿名类的匿名对象结束");
			}

			@Override
			public void stop() {
				System.out.println("匿名类的匿名对象结束");
			}
			
		});
	}
}
interface USB {
	void start();
	void stop();
}
class Printer implements USB{

	@Override
	public void start() {
		System.out.println("打印机工作");
	}

	@Override
	public void stop() {
		System.out.println("打印机停止工作");
	}
	
}
class CardReader implements USB {

	@Override
	public void start() {
		System.out.println("读卡器工作");
	}

	@Override
	public void stop() {
		System.out.println("读卡器停止工作");
	}
	
}
class Computer1 {
	public void Work(USB u) {
		u.start();
		u.stop();
	}
}

5 内部类

概念：允许一个类的定义位于另一个类的内部，前者为内部类，后者为外部类。

分类：

（1）成员内部类（类中）：①分为静态和非静态的成员内部类②定义在类的内部，方法外③四个权限修饰符，static、final、abstract可以其进行修饰④非静态成员内部类：1. 外部类外部类对象 = new 外部类（）； 2. 外部类.内部类内部类对象=外部类对象.new 内部类名（）；静态成员内部类：外部类.内部类名内部类对象 = new 外部类.内部类名（）；

（2）局部内部类：①局部内部类定义在方法中②定义局部内部类的方法一般有一个返回值（局部内部类的父类类型），返回局部内部类型的对象。

public class Test1 {
	public static void main(String[] args) {
		//原始方式实现输出产品的名称和颜色
		Product p = new RedPen();
		p.getColor();
		System.out.println(p.getName());
		
		//局部内部类实现输出产品的名称和颜色
		Test1 t = new Test1();
		t.getProduct().getColor();
		System.out.println(t.getProduct().getName());
	}
	
	public Product getProduct() {
		//局部内部类
//		class BlackPen implements Product {
//			@Override
//			public String getName() {
//				
//				return "黑笔";
//			}
//
//			@Override
//			public void getColor() {
//				System.out.println("黑色");
//			}			
//		}
//		return new BlackPen();
		//匿名内部类的匿名对象
		return new Product() {

			@Override
			public String getName() {
				
				return "蓝笔";
			}

			@Override
			public void getColor() {
				System.out.println("蓝色");
			}
			
		};
	}

}

interface Product {
	String getName();
	void getColor();
}
class RedPen implements Product {

	@Override
	public String getName() {
		
		return "红笔";
	}

	@Override
	public void getColor() {
		System.out.println("虹色");
	}
	
}