当前位置：首页 > news >正文

网站模板安装网站跳出率高还是低

news 2025/9/18 0:24:42

网站模板安装,网站跳出率高还是低,游戏交易平台,网络公司注册流程1.final,finally ,finalize final?修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final&…

1.final,finally ,finalize

final?修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载。

finally?再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。

finalize?方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

1. 基本介绍
1.1 多态的概念
多态是方法或对象具有多种形态，是面向对象的第三大特征。
多态的前提是两个对象（类）存在继承关系，多态是建立在封装和继承基础之上的。
1.2 多态的具体体现
对象的多态是多态的核心和重点。

规则：

一个对象的编译类型与运行类型可以不一致
编译类型在定义对象时，就确定了，不能改变，而运行类型是可以变化的
编译类型看定义对象时 = 号的左边，运行类型看 = 号的右边
1.3 入门案例
说明：

定义一个 Person 类作为父类，定义 Student 类和 Teacher 类作为子类继承父类；
Person 类拥有 mission() 方法；
Student 类和 Teacher 类重写父类的 mission() 方法；
最后在 main 函数中利用多态形式创建对象。
代码如下：

（1）定义父类 Person 类：

package Polymorphism;

public class Person {
   public void mission() {
       System.out.println("人要好好活着！");
   }
}

（2）定义子类 Student 类：

package Polymorphism;

public class Student extends Person {
   @Override
   public void mission() {
       System.out.println("学生要好好学习！");
   }
}

（3）定义子类 Teacher 类

package Polymorphism;

public class Teacher extends Person {
   @Override
   public void mission() {
       System.out.println("老师要好好教书！");
   }
}

（4）在 Test01 类中编写 main 函数，体现多态性

package Polymorphism;

//多态性
public class Test01 {
   public static void main(String[] args) {
       //多态形式，创建对象
       //注意编译类型看等号左边，运行类型看等号右边
       Person p1 = new Student();

       //此时调用的是 Student 类的 mission() 方法
       p1.mission();

       //多态形式，创建对象
       Person p2 = new Teacher();

       //此时调用的是 Teacher 类的 mission() 方法
       p2.mission();
   }
}

（5）运行结果

学生要好好学习！
老师要好好教书！

2. 多态的转型
2.1 向上转型
本质：父类的引用指向子类的对象

特点：

编译类型看左边，运行类型看右边
可以调用父类的所有成员（需遵守访问权限）
不能调用子类的特有成员
运行效果看子类的具体实现
语法：
父类类型引用名 = new 子类类型();
//右侧创建一个子类对象，把它当作父类看待使用

2.2 向下转型
本质：一个已经向上转型的子类对象，将父类引用转为子类引用

特点：

只能强制转换父类的引用，不能强制转换父类的对象
要求父类的引用必须指向的是当前目标类型的对象
当向下转型后，可以调用子类类型中所有的成员
语法：
子类类型引用名 = (子类类型) 父类引用;
//用强制类型转换的格式，将父类引用类型转为子类引用类型

2.3 代码示例
说明：

定义一个 Person 类作为父类，定义 Student 类和 Teacher 类作为子类继承父类；
Person 类拥有 mission() 方法；
Student 类和 Teacher 类重写父类的 mission() 方法并且分别拥有各自的特有的 score() 方法和 salary() 方法；
最后在 main 函数中演示转型。
代码如下：

（1）定义类：

package Poly_;

public class Person {
   public void mission() {
       System.out.println("人要好好活着！");
   }
}

class Student extends Person {
   @Override
   public void mission() {
       System.out.println("学生要好好学习！");
   }

   public void score() {
       System.out.println("学生得到好成绩！");
   }
}

class Teacher extends Person {
   @Override
   public void mission() {
       System.out.println("老师要好好教书！");
   }

   public void salary() {
       System.out.println("老师得到高工资！");
   }
}

（2）在 Test02 类中编写 main 函数，演示转型

package Poly_;

//转型演示
public class Test02 {
   public static void main(String[] args) {
       //向上转型（自动类型转换）
       Person p1 = new Student();

       //调用的是 Student 的 mission
       p1.mission();

       //向下转型
       Student s1 = (Student)p1;

       //调用的是 Student 的 score
       s1.score();
   }
}

（3）运行结果：

学生要好好学习！
学生得到好成绩！
1
2
2.4 转型的异常
2.4.1 类型转换异常
说明：使用强转时，可能出现异常，对2.3代码示例中的 Test02类重新编写，演示转型异常

代码如下：

//异常演示
public class Test02 {
   public static void main(String[] args) {
       //向上转型
       Person p1 = new Student();

       //调用的是 Student 的 mission
       p1.mission();

       //向下转型
       Teacher t1 = (Teacher) p1;

       //运行时报错
       p1.salary();
   }
}

解释：这段代码在运行时出现了 ClassCastException 类型转换异常，原因是 Student 类与 Teacher 类没有继承关系，因此所创建的是Student 类型对象在运行时不能转换成 Teacher 类型对象。

2.4.2 instanceof 比较操作符
为了避免上述类型转换异常的问题，我们引出 instanceof 比较操作符，用于判断对象的类型是否为XX类型或XX类型的子类型。

格式：对象 instanceof 类名称
解释：这将会得到一个boolean值结果，也就是判断前面的对象能不能当作后面类型的实例
代码示例：
package Poly_;

//演示 instanceof 的使用
public class Test03 {
   public static void main(String[] args) {
       //向上转型
       Person p1 = new Student();

       //调用的是 Student 的 mission
       p1.mission();

       //向下转型
       //利用 instanceof 进行判断
       if(p1 instanceof Student) {   //判断对象 p1 是否是 Student 类的实例
           Student s1 = (Student)p1;
           s1.score(); //调用的是 Student 的 score
           //上面这两句也可简写为 ((Student) p1).score();
       }
       else if(p1 instanceof Teacher){ //判断对象 p1 是否是 Teacher 类的实例
           Teacher t1 = (Teacher)p1;
           t1.salary(); //调用的是 Teacher 的 salary
           //同理，上面这两句也可简写为 ((Teacher) p1).salary();
       }
   }
}

运行结果：
学生要好好学习！
学生得到好成绩！
1
2
3.动态绑定（重点）
当调用对象方法的时候，该方法会和该对象的运行类型绑定
当调用对象属性时，没有动态绑定机制，即哪里声明，哪里使用。
代码示例：
package dynamic_;

//演示动态绑定
public class DynamicBinding {
   public static void main(String[] args) {
       //向上转型（自动类型转换）
       //程序在编译阶段只知道 p1 是 Person 类型
       //程序在运行的时候才知道堆中实际的对象是 Student 类型
       Person p1 = new Student();

       //程序在编译时 p1 被编译器看作 Person 类型
       //因此编译阶段只能调用 Person 类型中定义的方法
       //在编译阶段，p1 引用绑定的是 Person 类型中定义的 mission 方法（静态绑定）
       //程序在运行的时候，堆中的对象实际是一个 Student 类型，而 Student 类已经重写了 mission 方法
       //因此程序在运行阶段对象中绑定的方法是 Student 类中的 mission 方法（动态绑定）
       p1.mission();
   }
}

//父类
class Person {
   public void mission() {
       System.out.println("人要好好活着！");
   }
}

//子类
class Student extends Person {
   @Override
   public void mission() {
       System.out.println("学生要好好学习！");
   }
}

运行结果：
学生要好好学习！

4. 应用
4.1 多态数组
多态数组：数组的定义类型为父类类型，里面保存的实际元素类型为子类类型。
代码示例：（循环调用基类对象，访问不同派生类的方法）

说明：
定义一个 Person 类作为父类，定义 Student 类和 Teacher 类作为子类继承父类；
Person 类拥有 name(姓名) 属性以及 mission() 方法；
Student 类和 Teacher 类拥有各自特有的 score 和 salary 属性,，除此之外，重写父类的 mission() 方法；
要求：最后在 main 函数中创建一个 Person 对象、一个 Student 对象和一个 Teacher 对象，统一放在数组里，并调用每个对象的 mission() 方法。
代码如下：
（1）父类 Person 类：

package polyarr;

public class Person {
   private String name;

   public Person(String name) {
       this.name = name;
   }

   // getter 和 setter
   public String getName() {
       return name;
   }
   public void setName(String name) {
       this.name = name;
   }

   // mission() 方法
   public String mission() {
       return name + "\t" + "要好好活着";
   }
}

（2）子类 Student 类

package polyarr;

public class Student extends Person {
private double score;

   public Student(String name, double score) {
       super(name);
       this.score = score;
   }

   public double getScore() {
       return score;
   }

   public void setScore(double score) {
       this.score = score;
   }

   //重写父类的say方法
   @Override
   public String mission() {
       return super.mission() + " score =" + score + " 要好好学习！";
   }
}

（3）子类 Teacher 类

package polyarr;

public class Teacher extends Person {
private double salary;

   public Teacher(String name, double salary) {
       super(name);
       this.salary = salary;
   }

   public double getSalary() {
       return salary;
   }

   public void setSalary(double salary) {
       this.salary = salary;
   }

   //重写父类的 mission 方法
   @Override
   public String mission() {
       return super.mission() + " salary =" + salary + " 要好好教书！";
   }
}

（4）PolyArray 类中编写 main 函数

package polyarr;

/*
* 演示多态数组
* 创建一个 Person 对象
* 创建一个 Student 对象
* 创建一个 Teacher 对象
* 统一放在数组里，并调用每个对象的 mission() 方法。
*/
public class PolyArray {
   public static void main(String[] args) {
       Person[] persons = new Person[3];
       persons[0] = new Person("小汤");
       persons[1] = new Student("小韬", 100);
       persons[2] = new Teacher("小蒲", 10000);

       //循环遍历多态数组，调用 mission
       for(int i = 0; i < persons.length; i++) {
           //此处涉及动态绑定机制
           // Person[i] 编译类型是 Person ,运行类型根据实际情况由 JVM 判断
           System.out.println(persons[i].mission());
       }
   }
}

（5）运行结果：

小汤   要好好活着！
小韬   要好好活着！ score = 100.0 要好好学习！
小蒲   要好好活着！ salary = 10000.0 要好好教书！
1
2
3
4.2 多态参数
多态参数：方法定义的形参类型为父类类型，实参类型允许为子类类型。
代码示例：

说明：
定义一个 Person 类作为父类，定义 Student 类和 Teacher 类作为子类继承父类；
Person 类拥有 name(姓名) 属性
Student 类和 Teacher 类拥有各自特有的 study() 和 teach() 方法；
要求：最后在 main 函数中编写 test() 方法，功能是调用 Student 类的 study() 或 Teacher 类的 teach() 方法，用于演示多态参数的使用。
代码如下：
package polyparameter;

//演示多态参数
public class PolyParameter {
   public static void main(String[] args) {
       Student s1 = new Student("小蓝同学");
       Teacher t1 = new Teacher("小绿老师");

       //需先 new 一个当前类的实例化，才能调用 test 方法
       PolyParameter polyParameter = new PolyParameter();

       //实参是子类
       polyParameter.test(s1);
       polyParameter.test(t1);
   }

   //定义方法test，形参为 Person 类型(形参是父类)
   //功能：调用学生的study或教师的teach方法
   public void test(Person p) {
if (p instanceof Student){
((Student) p).study(); //向下转型
}
else if (p instanceof Teacher){
((Teacher) p).teach(); //向下转型
}
   }
}

//父类
class Person {
   private String name;

   //有参构造
   public Person(String name) {
       this.name = name;
   }

   // getter 和 setter
   public String getName() {
       return name;
   }
   public void setName(String name) {
       this.name = name;
   }
}

//子类
class Student extends Person {

   public Student(String name) {
       super(name);
   }

   // study() 方法
   public void study() {
       System.out.println(super.getName() + "\t" + "正在好好学习");
   }
}

class Teacher extends Person {

   public Teacher(String name) {
       super(name);
   }

   // teach() 方法
   public void teach() {
       System.out.println(super.getName() + "\t" + "正在好好教书");
   }
}

运行结果：
小蓝同学   正在好好学习
小绿老师   正在好好教书

5. 多态的优点
代码更加灵活：无论右边new的时候换成哪个子类对象，等号左边调用方法都不会变化。
提高程序的拓展性：定义方法的时候，使用父类类型作为参数，将来使用时，使用具体的子类类型操作

查看全文

http://www.yayakq.cn/news/286327/