Java中的多态和类型转换
一、Java中的多态
1.多态的进一步理解，多态可以理解为两个方面：
（1）父类型的引用可以指向子类型的实例或对象，
（2）接口类型的引用可以指向实现该接口的类的实例或对象（instance）。
由此来看，以后一提到多态，应该马上映射到向上转型。
2.接口就是一种特殊的抽象类，关键字interface，实现用implements。例如：结合数组定
义：
interface Interface1 implements Bb
{
}
Interface1[] = new Interface1[]{Bb(),Bb()};//数组
3.对象的多态一般就是两种形态：父类形态与本类形态。
子类的对象就在这两种形态之间相互转换。
（1）向上转型是把子类对象转成父类形态，限制子类的特有方法；
（2）向下转型是把子类对象从父类形态转成本类形态（向下转型的前提是先进行向上转型）。
4.Parent p = new Child（）；（1）当使用多态的方式调用方法时，首先检查父类中是否有此
方法，如果没有，则会出现编译出错，如果有则可编译通过，包括子类和父类都有此方法，子类的把父类的覆盖，调用的是子类中的此方法，如果子类中不存在此方法，直接调用父类的方法。因此编译时要看父类中是否存在此方法，调用时具体要看所指向对象的中的方法，先看子类方法的重写，若没有再调用从父类继承下来的方法。此规律仅限于成员方法。（2）*****对于成员变量，则只看引用所属类中是否有此变量，调用的也是父类中的变量值，与子类中的变量没有一点儿关系。
5.类类型的引用可以指向本类及其子类的对象；接口类型的引用可以用于指向
实现接口的子类的对象。这就是多态的体现。
6.这样让父类引用或接口引用作为形参，就可以接收很多子类的对象，拓展性
比较强。
7.多态：某一类事物的多种存在形态。
8.在java中多态的体现在：
（1）父类的引用可以指向本类及其子类的对象；
（2）接口的引用可以指向实现此接口的类的对象。
9.多态的好处：可以提高代码的复用性，提高代码的扩展性，前期定义的代码可以使用后
期的内容。
10.多态的弊端（局限性）：前期定义的内容不能使用（调用）后期子类的特有内容。
11.使用多态的前提：必须有关系：继承或者实现；要有覆盖（未经向下类型转换时，只能
调用父类或者接口中有的，且被覆盖的方法）。
父类型的引用可以指向其子类的对象，子类有很多，在父类引用接收子类对象后，如何进行判断并向下转型呢？利用instanceof进行判断，此关键词用于判断对象的具体类型，只可以用于引用数据类型的判断，如果父类引用指向子类对象，则父类引用instanceof 子类名如person Instanceof Student，返回true或者false。instanceof通常情况下在向下转型前用于健壮性的判断。
例如：publicstaticvoid specialMethod(Person p) {
if(p instanceof Student) {
Student s = (Student)p;
s.study();
}
elseif(p instanceof Worker) {
((Worker)p).work();
}
}
12.引入对象的多态后，对成员特点的分析：（十分重要）
注意：重载和重写（覆盖）都是指的是方法的重载和重写，特别是当说覆盖时，指的也只是方法，成员变量没有覆盖这么一说，因为子类和父类中有重名的变量时，子类在实例化时会把这两个变量都进行封装，用特定的标号加以区分。
（1）成员变量：编译时，查看引用类型所属类中是否拥有需要访问的变量，若有则编译通过，否则编译不通过。
编译和执行（调用）都是看引用（左边）。
此时只关注引用类型所属类中是否有此变量，所指向
的对象所属类有与没有此变量都无所谓。若都有，利
用父类型引用调用的是父类型中的变量值。
对于成员变量，存在多态时，无论是编译还是执行调
用，看的都是父类型引用所在的类，调用的变量也只
是父类中的变量，父类中没有则编译不通过，子类中
有与没有此变量都无关紧要。因为成员变量没有覆盖
这个概念之说，覆盖指的只是方法。
实例：class Animal{
int num = 6;//如果没有这句，则编译出错
}
class Dog extends Animal{
int num= 4;//这句话有或者没有，输出都是6，因为多态时，对于成员变量，只关注父类的成员变量，子类的不关心。
}
publicclass PolymorphismTest2 {
publicstaticvoid main(String[] args) {
Animal animal = new Dog();
int num = animal.num;
System.out.println(num);
}
}结果是：6
若在主函数中加上Dog dog = (Dog)animal;
System.out.println(dog.num);若子类定义了num=4；则此句话输出的就是4了。若子类中没有定义num变量，则输出的就是从父类继承下来的变量值，输出为6。
（2）成员方法：编译时，查看引用类型所属类中是否拥有需要访问的方法，若有则编译通过，否则编译不通过。
编译看引用（类），执行（调用）看（所指）对象。
引用类中如果没有定义此方法，则编译不通过，调用
执行时，首先调用子类中对此方法的重写方法，如没
有重写，直接调用引用类中的此方法。（原因：非静
态方法必须使用对象进行调用，静态方法可以不依赖
对象）
（3）静态方法：其实多态性指的是对象的多态性；但是静态方法根本不依赖于对象，所以严格意义上讲，静态
方法不涉及对象的多态性。直接利用相应类名进行访
问即可。对于静态方法，引用是什么类型，调用的就
是什么类型的静态方法，与子类中的静态方法无关。
对于静态方法，编译和执行调用都是看引用类型。
（4）分析：静态方法与成员变量一样，都是看引用类型。
只有成员方法比较特殊，因为一般成员方法都是依赖
于特定对象才能调用的。
13.
二、Java中对象的转型
1.（必须理解透彻）注意:一个引用能够调用哪些成员（成员变量和成
员方法），取决于这个引用本身是哪种类型，而调用的具体成员就是
所指向对象的成员了（一个引用调用的是哪一个方法，取决于这个引
用所指向的对象）。（通俗讲，就是能够调用哪些，看的是自身的类型，
调用到底是什么，看的是指向的对象。）
2.上面的描述就把多态的弊端展露出来了：父类型的引用指向了子类的
对象，但是不能调用子类特有的成员方法，限制对特有方法的调用，
接口也如此。
3.对象的向上转型：将子类的对象赋给父类的引用或者将父类的引用指
向子类的对象；向上类型转换就限制对子类的特有方法的调用。
4.对象的向下转型：将父类的对象（需要强制类型转换）赋值给子类的
引用或者将子类的引用指向父类的对象。只能是先进行向上转型，再进行向下
转型才可以，不可以直接生成一个父类对象，对其直接向下转型（这是错误的）。
例如：正确的：Person p = new Student（）；//首先向上转型
Student s1 = (Student) p ; //向下转型
5.注意：向下转移的前提是必须先向上转型，再向下转型。因为向下转型的引用
必须是指向子类对象的，才可以进行向下转型。
错误的：Person p = new Person（）；
Student s1 = (Student) p ; //编译时可能不会出错，但是执行的时候是错误的。
6.向上转型目的：提高扩展性，但是同时限制了子类特有功能的使用。
父类的引用指向子类的对象，但是此时能够调用哪些方法要看父类，具体调用
什么方法看所指向的对象，因此子类中特有的方法就不能被调用。
向下转型的目的：为了使用子类中的特有方法。
7.学生一定是人，但是人不一定是学生。
8.对象转型分为向上转型和向下转型。上下如何区分的：父类为上，子类为下。
9.向上转型的用处：由于父类的引用可以指向任何一个子类的对象，所以可以根
据情况让同一个父类引用指向不同的子类的不同的对象。
10.简单的说：转型都是对象的引用在进行指向的改变。
11.向上转型：记住：父类引用可以指向子类对象，不需要强制类型转换即可进行
向上转型；
向下转型：记住：父类的引用必须是指向子类对象的，才可以进行向下转型为
子类引用。
12.向下类型转换：从父类可以转向所指向的子类类型。
13.向上转型相当于把子类的特有属性隐藏掉了，若需要调用子类的特有属性，需
要进行向下转型。
14.一共有两种类型的强制类型转换：
第一种是向上类型转换（upcast）：将子类型转换成父类型，不需要显示指定；
如
Cat cat = new Cat（）；
Animal animal = cat；//向上类型转换，不需要显示指定
animal.sing;
第二种是向下类型转换（downcast）：将父类型转换成子类型，需要显示指定（必
须使用强制类型转换）。如
Animal a = new Cat（）；
Cat cat = （Cat）a；
cat.sing;
15.多态：综合：所谓多态就是，父类性的引用可以指向子类型的对象或
者接口类型的引用可以指向实现该接口的类的实例或对象。关于接口
与实现接口的类之间的强制类型转换方式与父类和子类之间的强制类型转换方
式完全一样。
16.如果类型转换出错，会抛出异常ClassCastException。
17.对于转型，自始至终都是子类对象在做着类型的变化。
实例：class Person{
publicvoid eat() {
System.out.println("person eat");
}
publicvoid run() {
System.out.println("person run");
}
}
class Student extends Person{
publicvoid study() {
System.out.println("student study");
}
publicvoid eat() {
System.out.println("student eat");
}
}
publicclass TypeTrans {
publicstaticvoid main(String[] args) {
Person p = new Student();//向上转型，但是不能利用p调用study方法p.eat();//调用重写后的方法，具体调用哪个方法看指向的对象
p.run();//没有重写，直接调用从父类继承下来的run方法
Student s = (Student)p;//向下转型
s.study();
}
}
18.
实验项目名称：继承和多态 （所属课程：Java语言程序设计） 院系：专业班级：姓名： 学号：实验地点：指导老师： 本实验项目成绩：教师签字：日期： 1．实验目的 （1）掌握类的继承机制。 （2）熟悉类中成员变量和方法的访问控制。 （3）熟悉方法或构造方法多态性。 2.实验内容 （1）模拟编写程序，理解类的继承、多态、继承和多态规则。 （2）独立编程，实现类的继承和多态。 3.实验作业 设计一个类Shape（图形）包含求面积和周长的area()方法和perimeter()方法以及设置颜色的方法SetColor()，并利用Java多态技术设计其子类Circle（圆形）类、Rectangle （矩形）类和Triangle（三角形）类，并分别实现相应的求面积和求周长的方法。每个类都要覆盖toString方法。 海伦公式：三角形的面积等于s(s-a)(s-b)(s-c)的开方，其中s=(a+b+c)/2 程序代码为： Class包 package Class; public class Shape { private String color = "while"; public Shape(String color){ this.color = color; } public void setColor(String color){ this.color = color; } public String getColor(){ return color;
} public double getArea(){ return 0; } public double getPerimeter(){ return 0; } public String toString(){ return"color:" + color; } } package Class; public class Circle extends Shape { private double radius; public Circle(String color,double radius) { super(color); this.radius = radius; } public void setRadius(double radius){ this.radius = radius; } public double getRadius(){ return radius; } public double getCircleArea(){ return 3.14*radius*radius; } public double getCirclePerimeter(){ return 3.14*2*radius; } public String toString(){
北大青鸟中关村 java对象转换String类型的三种方法在很多情况下我们都需要将一个对象转换为String类型。一般来说有三种方法可以实现：Object.toString()、(String)Object、String.valueOf(Object)。下面对这三种方法一一分析 一、采用Object.toString() toString方法是https://www.doczj.com/doc/9c4930853.html,ng.Object对象的一个public方法。在java中任何对象都会继承Object 对象，所以一般来说任何对象都可以调用toString这个方法。这是采用该种方法时，常派生类会覆盖Object里的toString()方法。 但是在使用该方法时要注意，必须保证Object不是null值，否则将抛出NullPointerException 异常。 二、采用(String)Object 该方法是一个标准的类型转换的方法，可以将Object转换为String。但是在使用该方法是要注意的是需要转换的类型必须是能够转换为String的，否则会出现CalssCastException异常错误。 代码代码如下: Object o = new Integer(100); String string = (String)o; 这段程序代码会出现https://www.doczj.com/doc/9c4930853.html,ng.ClassCastException: https://www.doczj.com/doc/9c4930853.html,ng.Integer cannot be cast to https://www.doczj.com/doc/9c4930853.html,ng.String。因为将Integer类型强制转换为String类型，无法通过。 三、String.valueOf(Object) 上面我们使用Object.toString()方法时需要担心null问题。但是使用该方法无需担心null值问题。因为在使用String.valueOf(Object)时，它会判断Object是否为空值，如果是，则返回null。下面为String.valueOf(Object)的源码： 代码代码如下: public static String valueOf(Object obj) { return (obj == null) ? "null" : obj.toString(); } 从上面我们可以看出两点：一是不需要担心null问题。二是它是以toString()方法为基础的。但是一定要注意：当object为null时，String.valueOf（object）的值是字符串对象："null"，而不是null！！！
JAVA的各种变量类型的转换 1 如何将字串 String 转换成整数 int? A. 有两个方法: 1).int i = Integer.parseInt([String]); i = Integer.parseInt([String],[int radix]); 2). int i = Integer.valueOf(my_str).intValue(); 注: 字串转成 Double, Float, Long 的方法大同小异. 2 如何将整数 int 转换成字串 String ? A. 有叁种方法: 1.) String s = String.valueOf(i); 2.) String s = Integer.toString(i); 3.) String s = "" + i; 注: Double, Float, Long 转成字串的方法大同小异. java的各种变量类型的转换 integer to String : int i = 42; String str = Integer.toString(i); String str = "" + i double to String : String str = Double.toString(i); long to String : String str = Long.toString(l); float to String : String str = Float.toString(f); String to integer : str = "25";
int i = Integer.valueOf(str).intValue(); int i = Integer.parseInt(str); String to double : double d = Double.valueOf(str).doubleValue(); String to long : long l = Long.valueOf(str).longValue(); long l = Long.parseLong(str); String to float : float f = Float.valueOf(str).floatValue(); decimal to binary : int i = 42; String binstr = Integer.toBinaryString(i); decimal to hexadecimal : int i = 42; String hexstr = Integer.toString(i, 16); String hexstr = Integer.toHexString(i); hexadecimal (String) to integer : int i = Integer.valueOf（"B8DA3",16).intValue(); int i = Integer.parseInt("B8DA3", 16); ASCII code to String int i = 64; String aChar = new Character((char)i).toString(); integer to ASCII code (byte) char c = 'A'; int i = (int) c; To extract Ascii codes from a Strin String test = "ABCD"; for ( int i = 0; i < test.length(); ++i ) {
实验五接口、多态与内部类 实验目标： 1、理解接口、塑型、多态的概念并能熟练应用； 2、熟练掌握接口的定义和使用； 3、深刻理解构造方法的调用顺序，理解编写时需要注意的问题； 4、了解并学会使用内部类 实验任务： 1、继承时的多态：目测给出下面代码的执行输出结果，并简单解释每一行输出的原因。 答：首先，该程序的主函数是Vehicle v=new Vehicle();即先声明并实例化一个汽车对象，而v.test();则是调用汽车的测试方法；而test方法里，Vehicle vc=new Car();是将上面的汽车指向了一个具体的小汽车对象；Bus vb=new Bus();将公共汽车指向了一个具体的公共汽车对象；drive();调用汽车的驾驶方法；vc.drive();调用小汽车的驾驶方法；vb.drive();调用公共汽车的驾驶方法；而vc.brake();vb.brake();则是直接调用汽车的刹车方法。因而运行结
果如下： A new bus. Vehicle is driven Car is driven Bus is driven Vehicle is braked Vehicle is braked 2.针对下面的简单的类图，从面向对象的角度，将Instrument定义成接口，应怎样实现。编写能完成如图功能的程序，并再编写一个简单的应用程序进行多态性测试。（参考例子5-9；实验4该题是要求用抽象类来实现，在此要求用接口实现，还要进行多态性测试） 说明：Instrument表示乐器、Wind表示管乐器、Percussion敲击乐器、Stringed表示弦乐器、Woodwind表示木管乐器、Brass表示铜管乐器。 要求：（1）Instrument为接口，Wind为抽象类，其他为普通类。这里测试的目的是：我们知道当一个普通类实现一个接口时，必须实现该接口的全部方法，但当这个类是抽象类时，我们还需要实现该接口全部方法吗？如果不需要实现？那么是否直接不理这个方法就一，还是要将这个方法在自己类内部再标记一次为抽象方法。（听起来有点晕，测试很简单的，有时百读不如一试） （2）请编写测试代码，对实现Instrument接口的各个类进行多态测试，具体可参考课本例子。所谓多态测试就是向上自动塑型，以及向下动态绑定，而动态绑定的基本规则是实例方法“由下往上”寻找绑定，类方法和类属性成员“由上往下”寻找绑定。（对其概念不清晰的请留意课本知识与课堂讲解） 该题代码如下： package zi; interface Instrument { void play(); String what(); void adjust(); }
Java多态的综合例子: package Test; public interface USBInterface { void start(); void conn(); void stop(); } package Test; public class MovingDisk implements USBInterface { @Override public void start() { // TODO Auto- System.out.println("移动设备已经插入，开始使用"); } @Override public void conn() { // TODO Auto-generated method stub System.out.println("移动设备已经连接，正在使用"); } @Override public void stop() { // TODO Auto-generated method stub System.out.println("移动设备已经退出"); } } package Test; public class Mouse implements USBInterface { public void start() { System.out.println("鼠标已插入，开始使用"); } @Override public void conn() { System.out.println("鼠标已经连接，正在使用中"); } @Override public void stop() {
System.out.println("鼠标拨出"); } } package Test; public class MainBorad { public void start() { System.out.println("主板加载成功"); } public void useUsb(USBInterface u) { u.conn(); u.start(); u.stop(); } } package Test; public class KeyBoard implements USBInterface { @Override public void start() { System.out.println("键盘已经插入，开始使用"); } @Override public void conn() { // TODO Auto-generated method stub System.out.println("键盘已经连接，正在使用"); } @Override public void stop() { // TODO Auto-generated method stub System.out.println("键盘已经拨出"); } } package Test; public class Test { /** * @param args
多态性是面向对象编程三个重要特性之一。Java中的多态性是通过综合应用继承、覆 盖，以及向上转型实现的。本章首先综合阐述面向对象编程的这些重要特征，引申到代码中的多态概念、多态带来的好处，以及多态能够解决的问题。然后通过实例详细讨论多态技术 在编程中的应用。 3：如何在程序中最有效地计算众多不同几何体的表面积comArea ()? 计算表面积的方法，如comArea，包括其 他类似方法，如comArea，print()，等等，都可应用多态来解决。因为这 些方法都可以针对不同的几何体，进行运算和操作。即：形态不一、方法相同、内容多样。 public abstract class shape { public double area(){ return 0; } public void print(){ } } public class sphere extends shape{ private double r; public sphere(double r){ this.r=r; } public void print(){ System.out.println("球的半径："+r); } public double area(){
return Math.PI*r*r*r*4/3; } } public class comArea { public static void main(String[] args) { shape h[]; h=new shape[2]; h[0]=new sphere(10); h[1]=new square(10,10,10); Operator.areaMax(h); } } public class Operator { //将长方形和圆看做Shape类型 public static void areaMax(shape h[]){ shape max; for(int i=1;i
Java常见异常类型及原因分析 这里介绍几种常见的异常并对原因进行分析，包括： ●NullPointException异常； ● ClassCastException异常； ● ArrayIndexOutOfBoundsException异常； ●UnsupportedClassVersionError错误； ●NumberFormatExceptio异常 ●堆栈溢出和内存溢出。 1 NullPointException异常 顾名思义，NullPointerException是空指针异常。但是在Java中没有指针，怎么会有空指针异常呢？ 在C++中，声明的指针需要指向一个实例（通过new方法构造），这个指针可以理解为地址。 在Java中，虽然没有指针，但是有引用（通常称为对象引用，一般直接说对象），引用也是要指向一个实例对象（通过new方法构造）的，从这种意义上说，Java中的引用与C++中的指针没有本质的区别，不同的是，处于安全的目的，在Java中不能对引用进行操作，而在C++中可以直接进行指针的运算，例如book++等。 所以这里的NullPointerException虽然不是真正的空指针异常，但本质上差不多，是因为引用没有指向具体的实例，所以当访问这个引用的方法的时候就会产生这种异常。例如下面的代码： String str = "这是一个测试用的字符串！"; System.out.println(str.length()); 这段代码没有问题，但是如果改成下面的代码： String str ; System.out.println(str.length()); 就会产生NullPointerException异常了，当然一般人不会犯这样低级的错误。 那这种异常通常是如何产生的呢？比较多见的是下面的两种情况： 1）把调用某个方法的返回值直接赋值给某个引用，然后调用这个引用的方法。在这种情况下，如果返回的值是null，必然会产生NullPointerException异常。例如： String userName=request.getParameter("userName"); if(userName.length()==0) ...... else ...... 如果request.getParameter("userName")的结果为null，则这里就会产生这种异常。 2）在方法体中调用参数的方法。这种情况下，如果调用方法的时候传递进来的值是null，也要产生NullPointerException异常。 要解决这种异常，只需要检查异常出现在第几行（通常在集成开发环境中会提示用户错误发生在第几行），然后查看调用了哪个对象的方法，然后检查这个对象为什么没有赋值成
java的基本数据类型有八种 各位读友大家好！你有你的木棉，我有我的文章，为了你的木棉，应读我的文章！若为比翼双飞鸟，定是人间有情人！若读此篇优秀文，必成天上比翼鸟！ java的基本数据类型有八种四类八种基本数据类型1. 整型byte（1字节）short （2个字节）int（4个字节）long （8个字节）2.浮点型float（4个字节）double（8个字节）3.逻辑性boolean（八分之一个字节）4.字符型char（2个字节，一个字符能存储下一个中文汉字）基本数据类型与包装类对应关系和默认值short Short （short）0int Integer 0long Long 0Lchar Char '\u0000'（什么都没有）float Floa t0.0fdouble Double 0.0dboolean Boolean false 若某个类的某个成员是基本数据类型，即使没有初始化，java也会确保它获得一个默认值，如上所示。（这种初始化方法只是用于成员变量，不适用于局部变量）。jdk1.5支持自动拆装箱。可以将基本数据类型转换成它的包装类装箱Integer a = new Integer （）；a = 100；拆箱int b = new Intger（100）；一个字节等于8位，一个字节等于256个数，-128到127一个英文字母或一个阿拉伯数字就是一个字符，占用一个字节一个汉字两个字符，占用两个字节基本数据类型自动转换byte->short , char->int->longfloat->doubleint ->floatlong->double小可转大，大转小会失去精度。字符串与基本类型或其他类型间的转换⑴其它
第3天面向对象 今日内容介绍 ◆接口 ◆多态 ◆笔记本案例 今日学习目标 ◆写出定义接口的格式 ◆写出实现接口的格式 ◆说出接口中成员的特点 ◆接口和抽象类的区别 ◆能够说出使用多态的前提条件 ◆理解多态的向上转型 ◆理解多态的向下转型 ◆能够完成笔记本电脑案例（方法参数为接口） 第1章接口 1.1接口概念 接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象的”类”。 接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离，优化了程序设计。 请记住：一切事物均有功能，即一切事物均有接口。
1.2接口的定义 与定义类的class不同，接口定义时需要使用interface关键字。 定义接口所在的仍为.java文件，虽然声明时使用的为interface关键字的编译后仍然会产生.class文件。这点可以让我们将接口看做是一种只包含了功能声明的特殊类。 定义格式： public interface 接口名 { 抽象方法1; 抽象方法2; 抽象方法3; } 使用interface代替了原来的class，其他步骤与定义类相同： ●接口中的方法均为公共访问的抽象方法 ●接口中无法定义普通的成员变量 1.3类实现接口 类与接口的关系为实现关系，即类实现接口。实现的动作类似继承，只是关键字不同，实现使用implements。 其他类(实现类)实现接口后，就相当于声明：”我应该具备这个接口中的功能”。实现类仍然需要重写方法以实现具体的功能。 格式： class 类 implements 接口 { 重写接口中方法 } 在类实现接口后，该类就会将接口中的抽象方法继承过来，此时该类需要重写该抽象方法，完成具体的逻辑。 ●接口中定义功能，当需要具有该功能时，可以让类实现该接口，只声明了应该具备 该方法，是功能的声明。 ●在具体实现类中重写方法，实现功能，是方法的具体实现。 于是，通过以上两个动作将功能的声明与实现便分开了。(此时请重新思考：类是现实事物的描述，接口是功能的集合。) 1.4接口中成员的特点 1、接口中可以定义变量，但是变量必须有固定的修饰符修饰，public static final 所以接口中的变量也称之为常量，其值不能改变。后面我们会讲解static与final关键字 2、接口中可以定义方法，方法也有固定的修饰符，public abstract 3、接口不可以创建对象。 4、子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。 interface Demo { ///定义一个名称为Demo的接口。
Java多态 1. Java中除了static和final方法外，其他所有的方法都是运行时绑定的。private 方法都被隐式指定为final的，因此final的方法不会在运行时绑定。当在派生类中重写基类中static、final、或private方法时，实质上是创建了一个新的方法。 2.在派生类中，对于基类中的private方法，最好采用不同的名字。 3.包含抽象方法的类叫做抽象类。注意定义里面包含这样的意思，只要类中包含一个抽象方法，该类就是抽象类。抽象类在派生中就是作为基类的角色，为不同的子类提供通用的接口。 4.对象清理的顺序和创建的顺序相反，当然前提是自己想手动清理对象，因为大家都知道Java垃圾回收器。 5.在基类的构造方法中小心调用基类中被重写的方法，这里涉及到对象初始化顺序。 6.构造方法是被隐式声明为static方法。 7.用继承表达行为间的差异，用字段表达状态上的变化。 在JAVA中有两种多态是指：运行时多态和编译时多态。 关于类的多态性简介如下： 多态(polymorphism)意为一个名字可具有多种语义.在程序设计语言中,多态性是指”一种定义,多种实现”.例如,运算符+有多种含义,究竟执行哪种运算取决于参加运算的操作数类型: 1+2 //加法运算符 “1” + “2” //字符串连接运算,操作数是字符串 多态性是面向对象的核心特征之一,类的多态性提供类中成员设计的灵活性和方法执行的多样性. 1、类多态性表现 (1)方法重载 重载表现为同一个类中方法的多态性.一个类生命多个重载方法就是为一种功能提供多种实现.编译时,根据方法实际参数的数据类型\个数和次序,决定究竟应该执行重载方法中的哪一个. (2)子类重定义从父类继承来的成员 当子类从父类继承来的成员不适合子类时,子类不能删除它们,但可以重定义它们,使弗雷成员适应子类的新需求.子类重定义父类成员,同名成员在父类与子类之间表现出多态性,父类对象引用父类成员,子类对象引用子类成员,不会产生冲突和混乱. 子类可重定义父类的同名成员变量,称子类隐藏父类成员变量.子类也可以重定义父类的同名成员方法，当子类方法的参数列表与父类方法参数列表完全相同时，称为子类方法覆盖
初学Java，对于类型转换以及强制类型转换还是没什么难度的，但是初学者往往在涉及到String类型的转换时，就会抛出问题了。这里收集整理了下，仅供参考。 int 转String int i=12345; String s=”"; 第一种方法：s=i+”"; 第二种方法：s=String.valueOf(i); 这两种方法有什么区别呢？作用是不是一样的呢？是不是在任何下都能互换呢？ String转int s=”12345″; int i; 第一种方法：i=Integer.parseInt(s); 第二种方法：i=Integer.valueOf(s).intValue(); 这两种方法有什么区别呢？作用是不是一样的呢？是不是在任何下都能互换呢？ 以下是答案：
3.) String s = “” + i; 注: Double, Float, Long 转成字串的方法大同小异. JAVA数据类型转换这是一个例子,说的是JAVA中数据数型的转换.供大家学习package shenmixiaozhu; import java.sql.Date; public class TypeChange { public TypeChange() { } //change the string type to the int type public static int stringToInt(String intstr) { Integer integer; integer = Integer.valueOf(intstr); return integer.intValue(); } //change int type to the string type public static String intToString(int value) { Integer integer = new Integer(value); return integer.toString(); } //change the string type to the float type public static float stringToFloat(String floatstr) { Float floatee; floatee = Float.valueOf(floatstr); return floatee.floatValue(); } //change the float type to the string type public static String floatToString(float value) { Float floatee = new Float(value); return floatee.toString(); } //change the string type to the sqlDate type public static java.sql.Date stringToDate(String dateStr) { return java.sql.Date.valueOf(dateStr); } //change the sqlDate type to the string type
实验5 继承、多态、接口和异常处理 一、实验目的 1、掌握Java的类和对象的声明和使用方法； 2、掌握Java的类的继承和实现方法； 3、掌握多态性在类的继承中的运用； 4、掌握接口的定义与使用； 5、掌握基本异常的处理机制； 6、熟悉try语句与catch语句的搭配使用； 7、了解有异常处理与没有异常处理的差别； 8、多重catch语句的使用； 9、使用Throws声明异常和Throw抛出异常。 二、实验环境 1、PC微机； 2、DOS操作系统或 Windows 操作系统； 3、Java sdk程序开发环境、eclipse集成环境。 三、实验内容 1. 设计三个类，分别是学生类Student，本科生类UnderGraduate，研究生类 Postjgraduate，其中Student类是一个抽象类，它包含学生的基本信息如姓名、所学课程、课程成绩等，而Undergraduate类和Postgraduate类都是Student类的子类，这两个类计算课程成绩等级的方法有所不同，如下表所示。假设某班级里既有研究生又有本科生，编写程序统计出全班学生 2. 和 Mobilephone具体实现，并设计一个应用程序类来使用这些类。 3．要求设计一个GUI图形窗口程序，该程序让用户输入一个星期中的任意一天的数字1-7，然后输出该数字所对应的是星期几。 四、实验步骤 实验内容一
1.建立package experiment5_1，其最终目录结构如下： 2.建立Student类： package experiment5_1; public abstract class Student { final static int CourseNo = 3; String name; String type; int[] courses; String courseGrade; public Student(String name) { https://www.doczj.com/doc/9c4930853.html, = name; courses = new int[CourseNo]; courseGrade = "" ; } public abstract void calculateGrade(); public String getName( ) { return name; } public String getType( ) { return type ; } public String getCourseGrade( ) { return courseGrade; } public int getCourseScore(int courseNumber) { return courses[courseNumber]; } public void setName(String name) { https://www.doczj.com/doc/9c4930853.html, = name; } public void setType(String type) { this.type = type; } public void setCourseScore(int courseNumber, int courseScore) { //按课程索引号设置课程成绩 this.courses[courseNumber] = courseScore ; } }
面向对象编程有三个特征，即封装、继承和多态。 封装隐藏了类的内部实现机制，从而可以在不影响使用者的前提下改变类的内部结构，同时保护了数据。 继承是为了重用父类代码，同时为实现多态性作准备。那么什么是多态呢？ 方法的重写、重载与动态连接构成多态性。Java之所以引入多态的概念，原因之一是它在类的继承问题上和C++不同，后者允许多继承，这确实给其带来的非常强大的功能，但是复杂的继承关系也给C++开发者带来了更大的麻烦，为了规避风险，Java只允许单继承，派生类与基类间有IS-A的关系（即“猫”is a “动物”）。这样做虽然保证了继承关系的简单明了，但是势必在功能上有很大的限制，所以，Java引入了多态性的概念以弥补这点的不足，此外，抽象类和接口也是解决单继承规定限制的重要手段。同时，多态也是面向对象编程的精髓所在。 要理解多态性，首先要知道什么是“向上转型”。 我定义了一个子类Cat，它继承了Animal类，那么后者就是前者是父类。我可以通过 Cat c = new Cat(); 实例化一个Cat的对象，这个不难理解。但当我这样定义时： Animal a = new Cat(); 这代表什么意思呢？ 很简单，它表示我定义了一个Animal类型的引用，指向新建的Cat类型的对象。由于Cat是继承自它的父类Animal，所以Animal类型的引用是可以指向Cat类型的对象的。那么这样做有什么意义呢？因为子类是对父类的一个改进和扩充，所以一般子类在功能上较父类更强大，属性较父类更独特， 定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。 所以，父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，它是无可奈何的； 同时，父类中的一个方法只有在在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用； 对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接。
Java语言基本数据类型、转换及其封装Java语言基本数据类型、转换及其封装 1. 逻辑类型 ·常量 true，false。 ·变量的定义 使用关键字boolean来定义逻辑变量： boolean x; boolean tom_12; 也可以一次定义几个： boolean x,tom,jiafei,漂亮 x，tom，jiafei，漂亮都是变量的名字。定义时也可以赋给初值： boolean x=true,tom=false,漂亮=true,jiafei 2.整数类型 ·常量123，6000（十进制），077（八进制），0x3ABC（十六进制）。 ·整型变量的定义分为4种： 1.int 型 使用关键字int来定义int型整形变量 int x int tom_12 也可以定义几个： int x,tom,jiafei,漂亮 x，tom，jiafei，漂亮都是名字。定义时也可以赋给初值： int x=12,tom=-1230,漂亮=9898,jiafei 对于int型变量，分配给4个字节byte,一个字节由8位（bit）组成，4个字节占32位（bit）。bit 有两状态，分别用来表示0，1。这样计算机就可以使用2进制数来存储信息了。内存是一种特殊的电子元件，如果把内存条放大到摩天大
楼那么大，那么它的基本单位——字节，就好比是大楼的房间，每个房间的结构都是完全相同的，一个字节由8个能显示两种状态的bit组成，就好比每个房间里有8个灯泡，每个灯泡有两种状态——亮灯灭灯。 对于 int x=7; 内存存储状态如下： 00000000 00000000 00000000 00000111 最高位：左边的第一位，是符号位，用来区分正数或负数，正数使用原码表示，最高位是0，负数用补码表示，最高位是1。例如： int x=-8; 内存的存储状态如下： 11111111 11111111 11111111 11111000 要得到-8的补码，首先得到7的原码，然后将7的原码中的0变成1，1变成0，就是-8的补码。 因此，int型变量的取值范围是-2^31~2^31-1。 2. byte型 使用关键字byte来定义byte型整型变量 byte x ; byte tom_12; 也可以一次定义几个： byte x,tom,jiafei,漂亮 x，tom，jiafei，漂亮都是名字。定义时也可以赋给初值： byte x=-12,tom=28,漂亮=98,jiafei 注：对于byte型变量，内存分配给1个字节，占8位，因此byte型变量的取值范围是： -2^7~2^7-1。
数据类型的转换是在所赋值的数值类型和被变量接收的数据类型不一致时发生的，它需要从一种数据类型转换成另一种数据类型。数据类型的转换可以分为隐式转换（自动类型转换）和显式转换（强制类型转换）两种。 隐式转换（自动类型转换） 如果以下 2 个条件都满足，那么将一种类型的数据赋给另外一种类型变量的时，将执行自动类型转换（automatic type conversion）。 ?两种数据类型彼此兼容 ?目标类型的取值范围大于源数据类型（低级类型数据转换成高级类型数据） 当以上 2 个条件都满足时，拓宽转换（widening conversion）发生。例如 byte 类型向 short 类型转换时，由于 short 类型的取值范围较大，会自动将 byte 转换为 short 类型。 在运算过程中，由于不同的数据类型会转换成同一种数据类型，所以整型、浮点型以及字符型都可以参与混合运算。自动转换的规则是从低级类型数据转换成高级类型数据。转换规则如下： ?数值型数据的转换：byte→short→int→long→float→double。 ?字符型转换为整型：char→int。 以上数据类型的转换遵循从左到右的转换顺序，最终转换成表达式中表示范围最大的变量的数据类型。 例 1 顾客到超市购物，购买牙膏 2 盒，面巾纸 4 盒。其中牙膏的价格是 10.9 元，面巾纸的价格是5.8 元，求商品总价格。实现代码如下： 1.public static void main(String[] args) { 2. float price1 = 10.9f; // 定义牙膏的价格 3. double price2 = 5.8; // 定义面巾纸的价格 4. int num1 = 2; // 定义牙膏的数量 5. int num2 = 4; // 定义面巾纸的数量 6. double res = price1 * num1 + price2 * num2; // 计算总价 7. System.out.println("一共付给收银员" + res + "元"); // 输出总价 8.} 上述代码中首先定义了一个 float 类型的变量存储牙膏的价格，然后定义了一个 double 类型的变量存储面巾纸的价格，再定义两个 int 类型的变量存储物品的数量，最后进行了乘运算以及和运算之后，将结果储存在一个 double 类型的变量中进行输出。 程序执行结果如下图 1 所示：
Java中的多态用法实例分析 多态分两种： (1)编译时多态（设计时多态）：方法重载。 (2)运行时多态：JAVA运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态。（我们平时说得多的事运行时多态，所以多态主要也是指运行时多态） 运行时多态存在的三个必要条件： 一、要有继承（包括接口的实现）； 二、要有重写； 三、父类引用指向子类对象。 详细解释： 运行时多态的解释：a.运行时多态是指程序中定义的引用变量所指向的具体类型和b.通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定. 1.程序序中定义的引用变量所指向的具体类型不确定(即一个引用变量倒底会指向哪个类的实例对象)。 例子： driver类中drive方法（Vehicle类vehicle）{} oneDriver.drive(newcar()) oneDriver.drive(newbus())
其中vehicle变量无法确定具体使用哪个子类实例。 1.通过该引用变量发出的方法调用在编程时并不确定(该引用 变量发出的方法调用到底是哪个类中实现的方法)。 例子:厨师，园丁，理发师的Cut方法调用.persion.cut(). 多态的好处： 1.可替换性（substitutability）。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。 2.可扩充性（extensibility）。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。 3.接口性（interface-ability）。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。如图8.3所示。图中超类Shape规定了两个实现多态的接口方法，puteArea()以及puteVolume()。子类，如Circle和Sphere为了实现多态，完善或者覆盖这两个接口方法。 4.灵活性（flexibility）。它在应用中体现了灵活多样的操作，提高了使用效率。 5.简化性（simplicity）。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。
《使用Java理解程序逻辑》1-4章阶段测试 一课后选择题 二、选择题 1、下列语句中，（ BD ）正确完成整形变量的声明和赋值。 A). int count,count=0; B). int count=0; C). count=0; D). int count1=0,count2=1; 2、在JAVA中，用于向控制台打印输出信息的语句是（A）。 A). System.out.println() B). System.println() C). Out.println() D). Print.println() 3、给定某Java程序的main方法如下所示，该程序的运行结果是（ A）。Public static void main(String[] args){ int i=0; System.out.println(i ); } (选择一项)A A). 输出0 B). 输出1 C). 编译错误 D). 运行时出现异常 4、在Java 中，下列代码的远行结果是（D ）。 public static void main(String[] args) { int a=1,b=2,c=3; if(a<0) if(b<0) c=10;
c=20; System.out.println(c); } A). 输出：10 B). 输出：20 C). 输出：3 D). 编译报错 5、在Java中,源文件Test.java中包括如下代码段,则程序编译运行结果是（b）。 public class Test{ public static void main(String[]args){ system.out.print(“Hello!”); } } A). a) 输出：Hello! B). b) 编译出错，提示“无法解析system” C). c) 运行正常，但没有输出任何内容 D). d) 运行时出现异常 6、在Java中，Scanner类提供从控制台获取键盘输入的功能，下列语句（ b）能够正确实例化Scanner类的对象，用于获得键盘输入的数据。 A). Scanner input = new Scanner(System.out) B). Scanner input = new Scanner(System.in) C). Scanner input = new Scanner(System) D). Scanner input = new Scanner() 7、下面程序的执行结果是（ c） public class Weather { public static void main(String[] args) { int shiDu=45; if(shiDu>=80){ System.out.println("要下雨了"); }else if(shiDu>=50){ System.out.println("天很阴"); }else if(shiDu>=30){ System.out.println("很舒适"); }else if(shiDu>=0){ System.out.println("很干燥");