小白进阶第六天

最新推荐文章于 2026-01-01 15:39:09 发布

原创最新推荐文章于 2026-01-01 15:39:09 发布 · 209 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#多态 #抽象类 #java #接口

本文深入探讨Java的高级面向对象特性，包括访问修饰符、方法重写、多态、静态与final修饰符、抽象类与接口的概念及应用。解析不同修饰符的作用范围，展示方法重写与多态如何增强代码灵活性，阐述静态与final修饰符的使用场景，以及抽象类与接口的设计原则。

1、访问修饰符

1、private

可以修饰变量，方法，不能修饰类只能访问本类

默认没有修饰的可以修饰变量、方法、类同一个包内可以访问

2、protected

可以修饰变量，方法可以访问同一个包，继承关系的不同包

3、public

可以修饰类，变量，方法可以访问任何地方

2、方法重写

继承关系

父类和子类方法名相同

参数列表相同

方法的返回类型相同（如果是继承关系，子类的方法类型<=父类）

class D1{
    public Demo1 f() {
	return null;
	}
}
class D2 extends D1{
    public Demo1 f() {
	return null;
	}
}

子类方法的访问修饰符>=父类

异常：子类方法的异常（非运行时异常）<=父类

为什么要进行重写？扩展父类方法的功能（私有方法不能被重写）

3、继承关系中构造方法的调用规则

（1）子类创建对象时，总是默认调用父类无参的构造方法

（2）如果父类没有无参的构造方法，使用super（）调用指定的构造方法

 class  A{
     int x;
     int y;
     public A(int x,int y){
           --------("A");
         }
      }          
   
    class B extends  A{
      public B(int x,int y){
        super（x,y）;
     ----------（“B”）;
     }
    }
   B b=new B(1,2）；

子类没有super找父类无参构造方法

4、多态

定义：一种类型的变量可以指向不同的对象

Animal a1=new Dog（）;
Animal a2=new Bird（）；

编译时的多态：方法的重载

class  A{
             void f（）{
           ---------------（“f”）；              
          }void f（int x）{
           ---------------（“f”+x）；
   
           }
 }
A a1=new A();
A a2=new A()；

a1.f();
a2.f(1);

运行时的多态：方法的重写

在Annimal类中定义eat Dog和Bird类重写了此方法

Animal a1=new Dog（）;      除重写外，其他都是父类
Animal a2=new Bird（）；

a1.eat();
a2.eat();

在编译时，看变量的声明类型
运行时，如果子类重写了父类的方法，动态绑定到子类上，运行子类的方法（没有动态绑定方法）

5、多态的应用

方法的参数定义为父类或者接口类型

对象造型：（对象强制转换）
通过instanceof进行对象的判断
instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例

public class Feeder {
	public void feed(Animal animal) {
		animal.eat();
	}
	
	//如果animal->dog   调用d（）
	//如果animal->bird  调用b（）
	public void test(Animal animal) {
		if(animal instanceof Dog) {
			((Dog)animal).d();
		}if(animal instanceof Bird) {
			((Bird)animal).b();
		}
	}
	public void test2() {
		Dog dog=new Dog();
		Bird bird=new Bird();
		//bird=(Bird)dog2;   //error 兄弟类不能强制转换
		Animal dog2=new Dog();
		bird=(Bird)dog2;   //运行时异常
	}
	public static void main(String[] args) {
		new Feeder().test2();
	}
	
}

1、static

修饰变量，方法，静态块

变量：成员变量->类变量（静态变量）由static修饰的成员变量
实例变量：没有static修饰
局部变量
类变量和实例变量的区别：
类变量对所有对象共享，公佣
实例变量是归对象所有，不是公用的
静态变量可以由类名调用
静态变量：类加载器加载类的时候初始化的
变量的初始化过程:
static int x=5；
int x=16；

修饰方法：
静态方法：由static修饰
实例方法：没有static修饰

int  x=1；
static int y=2；  
 void  f（）{
}
static void f2（）{
}

void test1（）{
   x=2；//ok
   y=3；
  f（）；  //ok
  f2（）；
 }

 static void test2（）{
    x=2；  //err
    y=3；
  f（）；//err   静态成员的初始化要先于实例成员，方法需要先创建对象，非静态的可以直接使用静态的，静态的不可以直接使用非静态的

  f2（）；
}

静态方法是否可以重写？ no，静态方法与对象无关
重载？ yes，
继承？ yes
构造方法是否可以定义静态的？ no 构造方法是创建对象用的

静态方法是否可以使用this，super ？ no

静态块
static{

}
写到类体中，在类加载时，执行一次

public class Hello{
   static{
   system.out.println("hello");
}
public static void main(String[] args){   
}
}

静态块和构造块
父类的静态块，子类的静态块，父类的构造块，父类的构造方法，子类的构造块，子类的构造方法

class A{
	static {
		System.out.println("1");
	}
	{
		System.out.println("2");
	}
	public A() {
		System.out.println("3");
	}	
}
class B extends A{
	static {
		System.out.println("A");
	}
	{
		System.out.println("B");
	}
	public B() {
		System.out.println("C");
	}	
}
public class Test2 {
	public static void main(String[] args) {
		new B();
	}

}

写到类体中
2、final

fimal 可以修饰类，方法，变量
final可以修饰变量的特点：常量
常量名：一般名字的所有字母都大写，如果有多个单词组成，单词之间用下划线
格式：final int PRUCE=10；
特点：不能改
final修饰的方法：不能重写，保证其唯一性
final修饰类：不能被继承

3、abstract

（1）抽象方法：由abstract修饰的方法
（2）特点：没有方法体
（3）抽象类：由abstract修饰的类 ------ 模块
（4）特点：不能创建对象
（5）抽象类中可以没有抽象方法
（6）抽象类由子类创建对象
（7）子类可以创建对象，实现所有的抽象方法，
没有实现全部的抽象方法，当前类声明为抽象类