本文深入解析Java中的static关键字、接口、多态及内部类等核心概念，包括静态成员的访问规则、接口的实现与成员、多态的访问规则及好处、内部类的分类与应用。通过实例代码展示，帮助读者理解并掌握Java编程的关键知识点。
1.static关键字
1.1static 概述
-
概述：
static表示静态，用于修饰（成员变量和成员方法）。被当前类所有对象所共享的变量定义成静态。
-
访问方式：
可以使用对象调用 对象.静态成员 也可以使用类名调用 类名.静态成员 建议：建议使用类名调用 -
示例代码：
//学生类 public class Student { //成员变量 String name; int age; static String school="一中"; //方法 public void show(){ System.out.println(name+","+age+","+school); } } //测试类 public class demo2 { public static void main(String[] args) { //创建对象 Student student=new Student(); student.name="王先生"; student.age=18; student.show(); Student student2=new Student(); student2.name="张师傅"; student2.age=18; student2.show(); } }
1.2static 成员的访问规则
访问规则：
- 静态只能直接访问静态，不能直接访问非静态。
- 非静态可以直接访问静态和非静态。
代码示例：
public class demo1 {
//静态变量
static int a;
//非静态变量
int b;
//静态方法
public static void mothod1(){
System.out.println(a);//静态方法可以访问静态变量
//System.out.println(b);//静态方法不可以访问非静态变量
method2(); //静态方法可以访问静态方法
//method3(); //静态方法不可以访问非静态方法
}
//静态方法
private static void method2() {
}
//普通方法
private void method3() {
System.out.println(a);
System.out.println(b);
mothod1();
method2();
method4();
}
//普通方法
private void method4() {
}
}
1.3静态内存图
1.4静态的使用场景
- 如果类中变量要被所有的对象所共享，这个变量就可以定义成为静态变量。
- 如果变量和方法想要在不创建对象的情况下使用，就可以定义成为静态变量或者静态方法。
- 如果变量和方法需要被静态方法直接调用，必须定义成静态的。
1.5静态的注意事项
- 静态只能直接调用静态，不能直接调用非静态。（原因先出现的不能调用后出现的）
- 只要只要你的代码因为静态报错，就一定是你用静态调用非静态。
- 静态方法中不能使用this关键字。
- 静态方法可以被继承，静态方法不能被重写。
2.接口
2.1接口的概念
- 概念：
- 接口就是规范，Java中一般某些父类定义成接口，子类需要按照接口的要求来写代码。
格式
-
public interface 接口名{ }
2.2接口的实现
类 实现 接口
开发中经常把实现关系也称为 子类 和 父类
因为实现的关系和继承的关系特别像，ccc也能继承aaa中的内容
- 格式：
public class ccc implements aaa{
}
2.3接口的成员
接口是比抽象更抽象的类
-
接口中的方法：
-
抽象方法
意义在于必须让子类重写，给子类提出了一些要求
//抽象方法 public abstract void method();
-
-
静态方法
- 意义在于能够直接调用
//静态方法 public static void method2(){ System.out.println("静态方法！！！"); } -
默认方法
- 意义在于能够给子类直接使用
//默认方法 public default void method3(){ System.out.println("默认方法"); } -
私有方法
- 意义在于提高本类代码的复用性
//私有方法 private void method4(){ System.out.println("私有方法"); } -
接口中的变量：
- 接口中的成员变量都是常量
2.4接口注意事项
- 我们习惯把实现和被实现的关系也叫做子类和父类的关系
- 接口中的成员变量是常量，默认有三个修饰符public static final
- 接口的普通方法都是抽象方法，默认有两个修饰符public abstract
- 接口中不能有构造方法，接口也不能被创建对象
- 接口的实现必须重写接口的所有抽象方法，或者实现类是一个抽象类
2.5类和接口的关系
- 类和接口的关系
类和类的关系：
单继承，一个类只能继承一个类，亲爹
类和接口的关系：
多实现，一个类可以实现多个接口，干爹
接口和接口的关系：
多继承，一个接口可以继承多个接口，一般不写。
开发中常见写法：
一个类在继承一个父类的情况下再实现多个接口
public class DDD extends AAA implements BBB,CCC{
}
- 可能存在的矛盾问题
-
两个父类中方法名和参数列表相同，返回值类型不同，报错。
-
两个接口中有相同的默认方法，子类就必须重写默认方法。
多个类本身就有矛盾，大家不用去记，如果遇到了就改掉。
2.6综合案例
//人类
public abstract class Person {
//成员变量
private String name;//姓名
private int age;//年龄
//抽象方法吃饭行为
abstract void eat();
//无参构造
public Person() {
}
//有参构造方法
public Person(String name, int age) {
this.name = name;
this.age = age;
}
//set/get
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
//运动员类
public abstract class Runner extends Person{
//定义抽象方法学习
public abstract void study();
//重写抽象方法
@Override
void eat() {
// System.out.println("吃营养餐！！！");
}
}
public abstract class Teacher extends Person {
//成员变量
private String id;//工号
public Teacher() {
}
public Teacher(String id) {
this.id = id;
}
public Teacher(String name, int age, String id) {
super(name, age);
this.id = id;
}
//教学
abstract void teach();
}
//说英语接口
public interface English {
void speack();
}
//篮球运动员
public class BBA extends Runner implements English{
private double height;//身高
public BBA() {
}
public BBA(double height) {
this.height = height;
}
@Override
public void study() {
System.out.println("学习打篮球！！！");
}
@Override
public void speack() {
System.out.println("说英语！！！");
}
}
//篮球教练
public class BBt extends Teacher implements English{
@Override
void teach() {
System.out.println("教打篮球！！！");
}
@Override
void eat() {
System.out.println("吃普通餐！！！");
}
@Override
public void speack() {
System.out.println("请说英语！！！");
}
}
//足球运动员
public class Sca extends Runner{
@Override
public void study() {
System.out.println("学习踢足球！！！");
}
}
//足球教练
public class SCt extends Teacher {
@Override
void teach() {
System.out.println("教踢乌龙球！！！");
}
@Override
void eat() {
System.out.println("吃豪华套餐！！！");
}
}
//测试类
public class demo1 {
public static void main(String[] args) {
//篮球教练
BBt b=new BBt();
b.eat();
b.speack();
b.teach();
//篮球运动员
BBA a=new BBA();
a.speack();
a.study();
//足球教练
SCt t=new SCt();
t.eat();
t.teach();
//足球运动员
Sca r=new Sca();
r.study();
r.eat();
}
}
3.多态
3.1多态的概念
- 概念
- 多态就是一个对象的多种表现形态，一个学生对象是一个学生类型，他也是人类类型。
- 示例代码
//把一个猫对象赋值给猫类型
Cat c = new Cat();
//把一个猫对象赋值给动物类型
Animal a = new Cat();
- 多态的前提
- 要有继承或者实现关系
- 要有方法重写
- 要有父类引用指向子类对象
3.2多态的成员访问规则
- 成员变量
- 编译看左边（父类），运行看左边（父类）。
- 成员方法
- 编译看左边（父类），运行看右边（子类）。
- 代码演示：
public class Animal {
//成员变量
String name = "王健林";
//成员方法
public void run(){
System.out.println("先赚他一个小目标");
}
}
public class Cat extends Animal {
//成员变量
String name = "王思聪";
//成员方法
public void run(){
System.out.println("先花他一个小目标");
}
}
public class Test {
public static void main(String[] args) {
//创建对象
Animal a = new Cat();
//编译看左边(父类)，运行看左边(父类)
System.out.println(a.name);
//编译看左边(父类)，运行看右边(子类)
a.run();
//王健林
//先花他一个小目标
}
}
3.3多态的好处和弊端
-
弊端
- 在多态的情况下，不能调用子类的特有方法。
-
好处
- 多态提高了代码的扩展性。
3.4多态的转型
-
向上转型
- 把子类类型转型成父类类型
Animal a = new Cat(); //多态本身就是向上转型 -
向下转型
- 把父类类型转成子类类型
Cat c = (Cat)a; //如果要调用子类的特有成员，就只能向下转型
- 类型转换异常
ClassCastException
出现了错误的向下转型时就会出现这个异常。
- instanceof关键字
对象 instanceof 类型
如果对象是后面的这种类型，结果就是true
如果对象不是后面的这种类型，结果就是false
- 代码演示
//转型的问题
public class Test01 {
//老王
public static void main(String[] args) {
method(new Cat());
}
//小王
public static void method(Animal a){
//先判断是否属于某种类型，再去向下转型
//避免出现类型转换异常
if(a instanceof Dog){
Dog d = (Dog)a;
}else if(a instanceof Cat){
Cat d = (Cat)a;
}
}
}
4.内部类
4.1内部类的概念
- 概念：
- 定义在类里面的类就是内部类。
- 分类：
- 成员内部类
- 局部内部类
- 匿名内部类
4.2成员内部类
- 概念：
- 定义在类中方法外的类就是成员内部类。
- 在测试类中创建对象的方式：
//创建对象
外部类.内部类 变量名 = new 外部类().new 内部类();
AAA.BBB ab = new AAA().new BBB();
- 变量重名时的访问：
外部类.this.成员变量名
- 示例代码：
//外部类
public class AAA {
//成员变量
int a = 1;
//成员内部类
public class BBB{
//成员变量
int a = 10;
public void method(){
//局部变量
int a = 20;
System.out.println(a); //20就近原则
System.out.println(this.a); //10
System.out.println(AAA.this.a); //1 外部类的成员变量
}
}
}
4.3局部内部类
- 概念：
- 定义在方法中的内部类就是局部内部类。
- 局部内部类的小问题：
- 局部内部类中调用外部类的局部变量时，这个变量会变成final变量，不能被修改。
- 在JDK7以前，需要手动加上final
- 在JDK8以后，只要局部内部类中使用变量就自动有了final
- 局部内部类中调用外部类的局部变量时，这个变量会变成final变量，不能被修改。
- 代码演示：
//外部类
public class Outer {
//方法
public void method(){
//局部变量
int a = 10;
//局部内部类
class Inner{
public void method(){
System.out.println(a);
//修改时报错
//a = 20;
System.out.println("局部内部类的方法");
}
}
}
}
4.4匿名内部类
- 概念：
- 匿名内部类是局部内部类的一种，匿名内部类就是没有类名的内部类。
- 格式：
父类/接口 变量名 = new 父类/接口(){
方法重写;
};
- 代码演示：
//方式一：
Animal a = new Animal(){
@Override
public void eat() {
System.out.println("重写方法");
}
};
//调用方法
a.eat();
//方式二：
new Animal(){
@Override
public void eat() {
System.out.println("重写方法");
}
}.eat();
- 本质
- 匿名内部类的本质其实就是一个子类对象。
- 匿名内部类的作用
- 匿名内部类的作用就是简化代码，可以少定义一个子类。
- 匿名内部类你想用就用，不想用也可以，但是你以后一定会用。当你对知识点熟悉之后，你一定会觉得越简单越好。
- 所有的类和接口都会生成.class文件
知识点：
static
记
访问方式
建议使用 类名.静态成员
访问规则
静态只能直接访问静态，不能直接访问非静态
接口
接口的定义
interface
实现方式
implements
成员
抽象方法 public abstract
成员变量 public static final
其他成员不重要
注意事项
都要理解
类和接口的关系
类和类 单继承
类和接口 多实现
接口和接口 多继承(不重要)
多态
必须理解，以后每一天都会用到多态
内部类
成员内部类
我们不会写但是会见到(不重要)
局部内部类
我们不写也不用(不重要)
匿名内部类
以后会经常习惯使用
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
