java 基础（二）

抽象的关键是抓住事物的两个方面：属性和功能。在实际生活中，我们每时每刻都与具体的事物在打交道，如我们用的钢笔、骑的自行车、乘坐的公交汽车等等。我们现在就可以对经常见到的卡车、公交汽车、小轿车进行抽象，找出它们共有的属性和功能，这里只会列举出部分：
属性：运行速度、发动机的功率。
功能:加速、减速、获取运行速度、设置发动机功率、获取发动机功率。
抽象的目的是从具体的实例中抽取共有属性和功能形成一种数据类型，比如我们的机动车类Vehicle，那么一个具体的轿车就是Vehicle类的一个实例，即对象。一个对象将自己的数据和对这些数据的操作合理有效的封装在一起，如我们的轿车调用“减速”改变的就是自己的运行速度。

public class Vehicle {
	double speed; // 变量声明部分,刻画速度
	int power; // 变量声明部分,刻画功率

	void speedUp(int s) { // 方法定义,刻画加速功能
		speed = speed + s;
	}

	void speedDown(int d) { // 方法定义,刻画减速功能
		speed = speed - d;
	}

	void setPower(int p) {
		power = p;
	}

	int getPower() {
		return power;
	}

	double getSpeed() {
		return speed;
	}
}

类

类是组成Java程序的基本要素。类封装了一类对象的状态和方法。类是用来定义对象的模板。
类的实现包括两部分：类声明和类体。基本格式为：

类声明

class 类名 {
类体的内容
}
class是关键字，用来定义类。“class 类名”是类的声明部分，类名必须是合法的Java标识符。两个大括号以及之间的内容是类体。

class Vehicle {
……
}
其中的“class Vehicle”称作类声明；“Vehicle”是类名。

◆ 给类命名时，遵守下列编程风格（这不是语法要求的，但应当遵守）：
1．如果类名使用拉丁字母，那么名字的首字母使用大写字母，如。
2．类名最好容易识别、见名知意。当类名由几个“单词”复合而成时，每个单词的首字母使用大写。

类体

◆类声明之后的一对大括号“{”，“}”以及它们之间的内容称作类体，大括号之间的内容称作类体的内容。
◆类体的内容由两部分构：一部分是变量的声明，用来刻画属性；另一部分是方法的定义，用来刻画功能。

成员变量

类体分为两部分：一部分是变量的声明，另一部分是方法的定义。
变量声明部分所声明的变量被称做域变量或成员变量
1．成员变量的类型：成员变量的类型可以是Java中的任何一种数据类型，包括基本类型：整型、浮点型、字符型；引用类型：数组、对象和接口。
2．成员变量的有效范围：成员变量在整个类内都有效，其有效性与它在类体中书写的先后位置无关。
3．编程风格
（1）一行只声明一个变量。
（2）变量的名字符合标识符规定。
（3）变量名字见名知意，避免容易混淆的变量名字。

方法

方法的定义包括两部分：方法声明和方法体。一般格式为：
方法声明部分 {
方法体的内容
}

方法声明

方法声明包括方法名和方法的返回类型，如：
double getSpeed() {
return speed;
}
注：方法的返回类型、方法的参数、方法的名字
1、return语句的作用：
a、返回一个值，这个值可以是任意类型。
b、使程序返回到操作系统（即终止程序）
2、java中对于一个函数，不论有没有返回值类型，都可以带有return 语句。但是区别在于，return 语句是否可以返回一个值（这取决与该函数的返回值类型）。
a、如果函数有返回值类型（即返回值类型不为void ），则必须带有返回相应类型值的return 语句。
b、如果函数没有返回值（即返回值类型为void ），则函数中return 语句（如果存在return语句！）的后面不能加任何的变量。（该情况下的函数中也可以没有return 语句，但是如果有的话，return 只能作为返回操作系统的作用使用。）

方法体

方法声明之后的一对大括号“{” ，“}”以及之间的内容称作方法的方法体。方法体的内容包括局部变量的声明和Java语句。
在方法体中声明的变量和方法的参数被称作局部变量。
局部变量只在声明它的方法内有效，而且与其声明的位置有关。方法的参数在整个方法内有效，方法内的局部变量从声明它的位置之后开始有效。如果局部变量的声明是在一个复合语句中，那么该局部变量的有效范围是该复合语。

注意事项

1、如果局部变量的名字与成员变量的名字相同，则成员变量被隐藏，即这个成员变量在这个方法内暂时失效。
如果想在该方法中使用被隐藏的成员变量，必须使用关键字this 。
2、类体的内容由两部分构成：一部分是变量的声明，另一部分是方法的定义。对成员变量的操作只能放在方法中，方法可以对成员变量和该方法体中声明的局部变量进行操作。在声明成员变量时可以同时赋予初值，但是不可以在类体中有单独的赋值语句（不可以有变量的声明和方法的定义以外的其它语句）。

构造方法和对象的创建

类是面向对象语言中最重用的一种数据类型，那么就可以用它来声明变量。在面向对象语言中，用类声明的变量被称作对象。和基本数据类型不同，在用类声明对象后，还必须要创建对象，即为声明的对象分配变量(确定对象所具有的属性)，当使用一个类创建一个对象时，也称给出了这个类的一个实例。通俗的讲，类是创建对象的“模板”，没有类就没有对象。构造方法和对象的创建密切相关。

构造方法

构造方法是一种特殊方法，它的名字必须与它所在的类的名字完全相同，而且没有类型。
允许一个类中编写若干个构造方法，但必须保证他们的参数不同，即参数的个数不同，或者是参数的类型不同。
需要注意的是
（1）如果类中没有编写构造方法，系统会默认该类只有一个构造方法，该默认的构造方法是无参数的，且方法体中没有语句。
（2）如果类里定义了一个或多个构造方法，那么Java不提供默认的构造方法。

创建对象

1．对象的声明
一般格式为：
类的名字对象名字;如：
Vehicle car;
这里Vehicle是一个类的名字，car是我们声明的对象的名字。

2.为声明的对象分配内存
使用new运算符和类的构造方法为声明的对象分配变量，即创建对象。如果类中没有构造方法，系统会调用默认的构造方法，默认的构造方法是无参数的，且方法体中没有语句。如：
car=new Vehiclee();

PS：见示例。

Person类

public class Person {
	int age;
	float height;
	
	  Person(int age){
		this.age = age;
	}
	 Person(float height){
		this.height = height;
	}

}

主类

public class Demo15 {

	public static void main(String[] args) {
		Person tom;
		tom = new Person(10);
		
		Person bob = new Person(1.8f);
	}

}

一、声明对象时的内存模型
Vehicle car1 ；

这时的car1是空对象，空对象不能使用，因为它还没有得到实体，必须再进行为对象分配变量的步骤。
二、对象分配内存后的内存模型
car1 = new Vehicle();

在这里做了以下两件事：
（1）Vehicle类中的成员变量speed和power被分配内存空间，然后执行构造方法中的语句。如果成员变量在声明时没有指定初值，所使用的构造方法也没有对成员变量进行初始化操作，那么对于整数类型，默认初值是0；对于浮点型，默认初值是0.0；对于boolean型，默认初值是false；对于引用类型，默认初值是null。
（2）new运算符在为变量speed和power分配内存以后，将得到一个引用，这个引用是一个十六进制数，包含有给这些成员变量所分配的内存位置等重要信息，如果将该引用赋值到对象变量car1中，就确保了car1得到了名字为speed和power的变量。
三、创建多个不同的对象

使用对象

对象不仅可以操作自己的变量改变状态，而且能调用类中的方法产生一定的行为。
通过使用运算符“.”，对象可以实现对自己变量的访问和方法的调用。
1．对象操作自己的变量（对象的属性）
对象.变量;
2．对象调用类中的方法（对象的功能）
对象.方法;
3．体现封装
当对象调用方法时，方法中出现的成员变量就是指分配给该对象的变量。

对象的引用和实体

类是体现封装的一种数据类型，类声明的变量称做对象，对象中负责存放引用，以确保对象可以操作分配给该对象的变量以及调用类中的方法。分配给对象的变量习惯地称做对象的实体。
1．避免使用空对象
没有实体的对象称作空对象，空对象不能使用，即不能让一个空对象去调用方法产生行为。
2．垃圾收集
一个类声明的两个对象如果具有相同的引用，那么二者就具有完全相同的实体，而且Java有所谓“垃圾收集”机制，这种机制周期地检测某个实体是否已不再被任何对象所拥有（引用），如果发现这样的实体，就释放实体占有的内存。

public class Demo15 {

	public static void main(String[] args) {
		Person tom;
		tom = new Person(10);
		
	Person bob = new Person(1.8f);
//		System.out.println("tom age:" + tom.age);
//		System.out.println("bob hieght:" + bob.height);
//		
//		tom.Speek();
//		bob.Speek();
//		
//		tom = null;
//		tom.Speek();
		tom = bob;
		System.out.println("tom age:" + tom.age);
		System.out.println("tom height:" + tom.height);
		System.out.println("bob age:" + bob.age);
		System.out.println("bob height:" + bob.height);
	}

}

参数传值

方法中最重要的部分之一就是方法的参数，参数属于局部变量，当对象调用方法时，参数被分配内存空间，并要求调用者向参数专递值，即方法被调用时，参数变量必须有具体的值

传递机制

在Java中，方法的所有参数都是“传值”的，也就是说，方法中参数变量的值是调用者指定的值的拷贝。例如，如果向方法的int型参数x传递一个int值，那么参数x得到的值是传递的值的拷贝。

基本数据类型的传值

对于基本数据类型的参数，向该参数传递的值的级别不可以高于该参数的级别。

引用类型参数的传值

当参数是引用类型时，“传值”传递的是变量中存放的“引用”，而不是变量所引用的实体。

可变参数

可变参数是指在声明方法时不给出参数列表中从某项直至最后一项参数的名字和个数，但这些参数的类型必须相同。可变参数使用“…”表示若干个参数，这些参数的类型必须相同，最后一个参数必须是参数列表中的最后一个参数。例如： public void f(int … x) 那么，方法f的参数列表中，从第1个至最后一个参数都是int型，但连续出现的int型参数的个数不确定。称x是方法f的参数列表中的可变参数的“参数代表”。
参数代表可以通过下标运算来表示参数列表中的具体参数，即x[0]，x[1]…x[m]分别表示x代表的第1个至第m个参数。

PS：见示例。

public class Computer {
	//可变参数
	public int getSum(int... x) {
		int sum = 0;
		for (int i = 0; i < x.length; i++)
			sum = sum + x[i];
		return sum;
	}
}


public class Demo16 {

	public static void main(String[] args) {
		Computer computer = new Computer();
		int result =computer.getSum(123,345,567);
		System.out.println("123,345,567之和："+result);
	}

}

实例成员与类成员

实例变量和类变量的声明

在之前的学习类的时候我们知道类体中包括成员变量的声明和方法的定义，而成员变量又可以细分为实例变量和类变量。在声明成员变量时，用关键字static给予修饰的称作类变量，否则称作实例变量（类变量也称为static变量，静态变量）。
class Dog {
float x; //实例变量
static int y; //类变量
}

实例变量和类变量的区别

1．不同对象的实例变量互不相同
我们已经知道，一个类通过使用new运算符可以创建多个不同的对象，这些对象将被分配不同的成员变量。再准确的说，就是分配给不同对象的实例变量占有不同的内存空间，改变其中一个对象的实例变量不会影响其他对象的实例变量。
2．所有对象共享类变量
如果类中有类变量，当使用new运算符创建多个不同的对象时，分配给这些对象的类变量占有相同的一处内存，改变其中一个对象的类变量就会影响其他对象的类变量。
3．通过类名直接访问类变量
当Java程序执行时，类的字节码文件被加载到内存中，如果该类还没有创建对象，那么类中的实例变量就不会被分配内存。但是，类中的类变量，在该类被加载到内存中时，就分配了相应的内存空间。如果该类创建对象，那么不同对象的实例变量互不相同，即分配不同的内存空间，但是类变量就不再重新分配内存，所有的对象共享类变量，即所有的对象的类变量是相同的一处内存空间，类变量的内存空间直到程序退出运行，才会释放所占有的内存。

PS：见示例。

实例方法和类方法的定义

类中的方法也可分为实例方法和类方法。方法声明时，方法类型前面不加关键字static修饰的是实例方法、加static关键字修饰的是类方法(静态方法)。
class A {
int a;
float max(float x,float y) { //实例方法
…
}
static float jerry() { //类方法
…
}
static void speak(String s) { //类方法
…
}
}

实例方法和类方法的区别

1．对象调用实例方法
当对象调用实例方法时，该方法中出现的实例变量就是分配给该对象的实例变量；该方法中出现的类变量也是分配给该对象的变量，只不过这个变量和所有的其他对象共享而已。
2．类名调用类方法
类方法不仅可以被类创建的任何对象调用执行，也可以直接通过类名调用。和实例方法不同的是，类方法不可以操作实例变量，这是因为在类创建对象之前，实例成员变量还没有分配内存。

PS：见示例。


public class Ladder {
	double top; //实例变量
	static double bottom;//类变量
	public double getTop() {
		return top;
	}
	public void setTop(double top) {
		this.top = top;
	}
	public static double getBottom() {
		return bottom;
	}
	public static void setBottom(double bottom) {
		Ladder.bottom = bottom;
	}
}


public class Demo17 {

	public static void main(String[] args) {
		Ladder.bottom =100;
		Ladder ladder1 = new Ladder();
		Ladder ladder2 = new Ladder();
		ladder1.setTop(50);
		ladder2.setTop(60);
		System.out.println("ladder1的上底：" + ladder1.getTop());
		System.out.println("ladder1的下底：" + ladder1.getBottom());
		System.out.println("ladder2的上底：" + ladder2.getTop());
		System.out.println("ladder2的下底：" + ladder2.getBottom());
		
		System.out.println("1-10之和："+Sum.getSum(1, 10));
	}

}

class Sum{
	static int getSum(int start,int end) {
		int sum = 0;
		for (int i=start;i < end; i++) {
			sum+=i;
		}
		return sum;
	}
}

方法重载和this关键字

方法重载的意思是：一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同，即或者是参数的个数不同，或者是参数的类型不同。
class A {
float add(int a,int b) {
return a+b;
}
float add(long a,int b) {
return a+b;
}
double add(double a,int b) {
return a+b;
}
}

PS：见示例。

Cicrle.java

public class Circle {
	double radius,area;
	void setRadius(double r) {
		radius = r;
	}
	
	double getArea() {
		area = 3.14 * radius*radius;
		return area;
	}
}

Ladder.java

public class Ladder {
	double top,bottom,height;
	
	public Ladder(double a,double b,double h) {
		top = a;
		bottom = b;
		height = h;
	}
	
	double getArea() {
		return (top + bottom) * height /2;
	}
}

Pepole.java

public class People {
	double computerArea(Circle c) {
		return c.getArea();
	}

	double computerArea(Ladder l) {
		return l.getArea();
	}
}

Demo18.java


public class Demo18 {

	public static void main(String[] args) {
		Circle circle = new Circle();
		circle.setRadius(12.5);
		
		Ladder ladder = new Ladder(10,20,15);
		People pepole = new People();
		System.out.println("pepole计算圆的面积"+pepole.computerArea(circle));
		System.out.println("pepole计算梯形的面积"+pepole.computerArea(ladder));
		
		Test test = new Test();
		test.speek(3);
		

	}

}

class Test{
	double a = 4;
	
	void speek(double a)
	{
		System.out.println("a=" + a);
		System.out.println("a=" + this.a);
	}
}

程序运行结果

pepole计算圆的面积490.625
pepole计算梯形的面积225.0
a=3.0
a=4.0

this是Java的一个关键字，表示某个对象。this可以出现在实例方法和构造方法中，但不可以出现在类方法中。
实例方法可以操作类的成员变量，当实例成员变量在实例方法中出现时，默认的格式是：
this.成员变量;
当static成员变量在实例方法中出现时，默认的格式是：
类名.成员变量;
当一个对象调用方法时，方法中的实例成员变量就是指分配给该对象的实例成员变量，而static变量则和其他对象共享。因此，通常情况下，可以省略实例成员变量名字前面的“this.”，以及static变量前面的“类名.”。
但是，当实例成员变量的名字和局部变量的名字相同时，成员变量前面的“this.”或“类名.”就不可以省略。
注：this不能出现在类方法中，这是因为，类方法可以通过类名直接调用，这时，可能还没有任何对象诞生。

包和import语句

包是Java语言中有效地管理类的一个机制。
包名的目的是有效的区分名字相同的类。不同Java源文件中两个类名字相同时，它们可以通过隶属不同的包来相互区分。

包语句

通过关键字package声明包语句。
package语句作为Java源文件的第一条语句，为该源文件中声明的类指定包名。
package语句的一般格式为：
package 包名;
例如：
package sunrise;
package sun.com.cn;

有包名的类的存储目录

如果一个类有包名，那么就不能在任意位置存放它，否则虚拟机将无法加载这样的类。
程序如果使用了包语句,例如：package tom.jiafei;
那么存储文件的目录结构中必须包含有如下的结构
…\tom\jiafei
如：
c:\1000\tom\jiafei
并且要将源文件编译得到的类的字节码文件保存在目录c:\1000\tom\jiafei中（源文件可以任意存放）。

运行有包名的主类

如果主类的包名是tom.jiafei，那么主类的字节码一定存放在…\tom\jiefei目录中，运行时必须到tom\jiefei的上一层（即tom的父目录）目录中去运行主类。
假设tom\jiefei的上一层目录是1000，那么，必须如下格式来运行：
C:\1000\java tom.jiafei.主类名

PS：见示例。

import语句

引入类库中的类

使用import语句可以引入包中的类。在编写源文件的时候，除了自己编写的类以外，经常需要使用Java提供的许多类，这些类可能在不同的包中。在学习Java语言时，使用已经存在的类，避免一切从头做起，这也是面向对象编程的一个重要方面。
为了能够使用Java提供给我们的类，可以使用import语句引入包中类。在一个Java源程序中可以有多个import语句，它们必须写在package语句（假如有package语句的话）和源文件中类的定义之间。Java为我们提供了大约130多个包，比如：
java.lang 包含所有的基本语言类
javax.swing 包含抽象窗口工具集中的图形、文本、窗口GUI类
java.io 包含所有的输入输出类
java.util 包含实用类
java.sql 包含操作数据库的类
java.nex 包含所有实现网络功能的类
java.applet 包含所有实现Java applet的类

引入自定义包中的类

用户程序可以使用tom.jiafei包中的类
如：import tom.jiafei.*;
使用非类库中有包名的类，也要使用import语句。

使用无包名的类

之前，我们在源文件中一直没有使用包语句，因此各个源文件得到的类都没有包名。如果一个源文件中的类想使用无名包中的类，只要将这个无包名的类的字节码和当前类保存在同一目录中即可。

避免类名混淆

1．区分无包名和有包名的类
如果一个源文件使用了一个无名包中的A类，同时又用import语句引入了某个有包名的同名的类，如tom.jiafei中的A类，就可能引起类名的混淆。
2．区分有包名的类
如果一个源文件引入了两个包中同名的类，那么在使用该类时，不允许省略包名。

package com.jiafei;

import com.jiafie.person.Bom;
import com.jiafie.person.Tom;

import javafx.scene.shape.Circle;

public class Demo19 {

	public static void main(String[] args) {
		System.out.println("我的包名是com.jiafei");
		Bom bom = new Bom();
		
		Circle circle = new Circle();
		Tom tom = new Tom();
		com.jiafei.pic.Tom tom1 = new com.jiafei.pic.Tom();
		
	}

}

访问权限

当用一个类创建了一个对象之后，该对象可以通过“.”运算符操作自己的变量、使用类中的方法，但对象操作自己的变量和使用类中的方法是有一定限制的。
所谓访问权限是指对象是否可以通过“.”运算符操作自己的变量或通过“.”运算符使用类中的方法。
访问限制修饰符有private、protected和public，都是Java的关键字，用来修饰成员变量或方法。

私有变量和私有方法

对于私有成员变量或方法，只有在本类中创建该类的对象时，这个对象才能访问自己的私有成员变量和类中的私有方法。
class Tom {
private float weight;
private float f(float a,float b){
return a+b;
}
}
class Jerry {
void g() {
Tom cat=new Tom();
cat.weight=23f; //非法
float sum=cat.f(3,4); //非法
}
}

共有变量和共有方法

用public修饰的成员变量和方法被称为共有变量和共有方法。
我们在任何一个类中用类Tom 创建了一个对象后，该对象能访问自己的public变量和类中的public方法（也可以通过类名来操作成员变量、方法）。
class Tom {
public float weight;
public float f(float a,float b) {
return a+b;
}
}
class Jerry {
void g() {
Tom cat=new Tom();
cat.weight=23f; //合法
float sum=cat.f(3,4); //合法
}
}

受保护的变量和方法

用protected修饰的成员变量和方法被称为受保护的成员变量和受保护的方法。
我们在任何一个类中用类Tom 创建了一个对象后，如果这个类和类Tom在同一个包中，那么该对象能访问自己的protected变量和类中的protected方法。
class Tom {
protected float weight;
protected float f(float a,float b) {
return a+b;
}
}
class Jerry {
void g() {
Tom cat=new Tom();
cat.weight=23f; //合法
float sum=cat.f(3,4); //合法
}

友好变量和友好方法

不用private、public、protected修饰的成员变量和方法被称为友好变量和友好方法。
我们在任何一个类中用类Tom 创建了一个对象后，如果这个类和类Tom在同一个包中，那么该对象能访问自己的友好变量和类中的友好方法。
class Tom {
float weight;
float f(float a,float b) {
return a+b;
}
}
class Jerry {
void g() {
Tom cat=new Tom();
cat.weight=23f; //合法
float sum=cat.f(3,4); //合法
}

public类与友好类

类声明时，如果在关键字class前面加上public关键字，就称这样的类是一个public 类。
可以在任何另外一个类中，使用public类创建对象。
如果一个类不加public修饰，这样的类被称作友好类。
在另外一个类中使用友好类创建对象时，要保证它们是在同一包中。
注：
（1）不能用protected和private修饰类
（2）访问限制修饰符按访问权限从高到低的排列顺序是：public、ptotected、友好的、private。

子类和继承

利用继承，可以先编写一个共有属性的一般类，根据该一般类再编写具有特殊属性的新类，新类继承一般类的状态和行为，并根据需要增加它自己的新的状态和行为。
由继承而得到的类称为子类，被继承的类称为父类（超类）。
声明一个类的子类的格式如下：
class 子类名 extends 父类名 {
… …
}
例如：
class Student extends People {
… …
}

子类的继承性

所谓子类继承父类的成员变量作为自己的一个成员变量，就好象它们是在子类中直接声明一样，可以被子类中自己定义的任何实例方法操作。
所谓子类继承父类的方法作为子类中的一个方法，就象它们是在子类中直接定义了一样，可以被子类中自己定义的任何实例方法调用。

子类与父类在同一包中的继承性

如果子类和父类在同一个包中，那么，子类自然地继承了其父类中不是private的成员变量作为自己的成员变量，并且也自然地继承了父类中不是private的方法作为自己的方法，继承的成员变量或方法的访问权限保持不变。

子类与父类不在同一包中的继承性

如果子类和父类不在同一个包中，那么，子类继承了父类的protected、public成员变量做为子类的成员变量，并且继承了父类的protected、public方法为子类的方法，继承的成员或方法的访问权限保持不变。

关于instanceof运行符

instanceof运算符是Java独有的运算符号。
instanceof是双目运算符，其左面的操作元是对象，右面的操作元是类，当左面的操作元是右面的类或子类所创建的对象时，instanceof运算的结果是true，否则是false。

成员变量的隐藏

在编写子类时，我们仍然可以声明成员变量，一种特殊的情况是，如果所声明的成员变量的名字和从父类继承来的成员变量的名字相同（声明的类型可以不同），在这种情况下，子类就会隐藏掉所继承的成员变量，即子类重新声明定义了这个成员变量。需要注意的是，子类对象仍然可以调用从父类继承的方法操作隐藏的成员变量。

方法重写

子类通过重写可以隐藏已继承的实例方法。
1．重写的语法规则
如果子类可以继承父类的某个实例方法，那么子类就有权利重写这个方法。
方法重写是指：子类中定义一个方法，这个方法的类型和父类的方法的类型一致或者是父类的方法的类型的子类型，并且这个方法的名字、参数个数、参数的类型和父类的方法完全相同。
2．重写的目的
子类通过方法的重写可以隐藏继承的方法，子类通过方法的重写可以把父类的状态和行为改变为自身的状态和行为。
3．JDK 1.5对重写的改进
在JDK 1.5版本之后,允许重写方法的类型可以是父类方法的类型的子类型,即不必完全一致.也就是说,如果父类的方法的类型是“类”,重写方法的类型可以是“子类”。
4．重写的注意事项
重写父类的方法时，不可以降低方法的访问权限。

Super关键字

在子类中想使用被子类隐藏的成员变量或方法就可以使用关键字super。
比如super.x、super.play()就是访问和调用被子类隐藏的成员变量x和方法play()。

对象的上转型对象

假设，A类是B类的父类，当用子类创建一个对象，并把这个对象的引用放到父类的对象中时，此时这个父类的对象就称之为子类创建的对象的上转型对象，比如：
A a;
B b=new B();
a=b;
或者
A a;
a=new B();
或者
A a=new B();

变化

注意事项

1、不要将父类创建的对象和子类对象的上转型对象混淆。
2、可以将对象的上转型对象再强制转换到一个子类对象，这时，该子类对象又具备了子类所有属性和功能。
3、不可以将父类创建的对象的引用赋值给子类声明的对象

Person.java


public class Person {
	int height;
	
	void showBodyMessage() {
		System.out.println("showBodyMessage");
	}
	void mustDoThings() {
		System.out.println("吃饭，喝水，睡觉");
	}
}

Chinese.java


public class Chinese extends Person {
	@Override
	void showBodyMessage() {
		System.out.println("身高" + height);
	}

}

American.java


public class American extends Person {
	@Override
	void showBodyMessage() {
		System.out.println("my height:" + height);
	}
	
	void speek() {
		System.out.println("englisg");
	}

}

Demo23.java


public class Demo23 {

	public static void main(String[] args) {
		Person person =null;
		
		American tom = new American();
		
		person =tom;
		person.height=178;
		person.showBodyMessage();
		person.mustDoThings();
		//person.speekEnglist();
		
		Chinese zhangsan =new Chinese();
		person = zhangsan;
		person.height= 190;
		person.showBodyMessage();
		person.mustDoThings();
		
		zhangsan = (Chinese)person;
		//person.speekChinese();
		
		
	}

}

继承与多态

当一个类有很多子类时，并且这些子类都重写了父类中的某个实例方法，那么当我们把子类创建的对象的引用放到一个父类的对象中时，就得到了该对象的一个上转型对象，那么这个上转型对象在调用这个实例方法时就可能具有多种形态，因为不同的子类在重写父类的实例方法时可能产生不同的行为。

多态性就是指父类的某个实例方法被其子类重写时，可以各自产生自己的功能行为。

Demo24.java


public class Demo24 {

	public static void main(String[] args) {
		Car car = new PoliceCar();
		car.cautinSound();
		car = new AmbulanCar();
		car.cautinSound();
		car = new FireCar();
		car.cautinSound();
	}

}

Car.java


public class Car {
	void cautinSound() {
		
	}
}

PoliceCar.java


public class PoliceCar  extends Car{
	@Override
	void cautinSound() {
		System.out.println("zhua...zhua...zhua");
	}
}

AmbulainCar.java


public class AmbulanCar extends Car {
	@Override
	void cautinSound() {
		System.out.println("jiu...jiu...jiu");

	}
}

FireCar.java


public class FireCar  extends Car{
	@Override
	void cautinSound() {
		System.out.println("huo...huo...huo");
	}
}

abstract 类和abstract方法

用关键字abstract修饰的类称为abstract类（抽象类）。如：
abstract class A {
…
}
用关键字abstract修饰的方法称为abstract方法（抽象方法），例如：
abstract int min(int x,int y);

注意事项

1、和普通的类相比，abstract类可以有abstract方法，也可以有非abstract方法。
2、对于abstract类，我们只能声明，不能使用new运算符创建该类的对象。如果一个非抽象类是某个抽象类的子类，那么它必须重写父类的抽象的方法，给出方法体。
3、abstract类也可以没有abstract方法。
4、如果一个abstract类是abstract类的子类，它可以重写父类的abstract方法，也可以继承这个abstract方法。
5、对于abstract方法，只允许声明，不允许实现。

面向抽象编程

在设计一个程序时,可以通过在abstract类中声明若干个abstract方法,表明这些方法在整个系统设计中的重要性,方法体的内容细节由它的非abstract子类去完成。
使用多态进行程序设计的核心技术之一是使用上转型对象，即将abstract类声明对象作为其子类的上转型对象，那么这个上转型对象就可以调用子类重写的方法。
所谓面向抽象编程,是指当设计某种重要的类时,不让该类面向具体的类,而是面向抽象类,即所设计类中的重要数据是抽象类声明的对象,而不是具体类声明的对象。

接口与多态

Java除了平台无关的特点外，从语言的角度来看，Java的接口是该语言的又一特色。Java舍弃了C++语言中多重继承的机制，使得编写的代码更加健壮和便于维护，因为多继承不符合人的思维模式，就像生活中，人只有一个父亲，而不是多个。尽管多继承可以使编程者更加灵活的设计程序，但是程序会显得难于阅读和维护。
Java不支持多继承性，即一个类只能有一个父亲。单继承性使得Java简单，易于管理和维护。那么为了克服Java单继承的缺点，Java使用了接口，一个类可以实现多个接口，Java的接口更加符合人的思维方式。

接口的声明和使用

使用关键字interface来定义一个接口。
接口的定义和类的定义很相似，分为接口的声明和接口体。

接口的声明和使用

接口通过使用关键字interface来声明，格式：
interface 接口的名字

接口体

接口体中包含常量的声明（没有变量）和方法定义两个部分。接口体中只有抽象方法，没有普通方法，而且接口体中所有的常量的访问权限一定都是public（允许省略public、final修饰符），所有的抽象方法的访问权限一定都是public（允许省略public、abstract修饰符），例如：
interface Test{
public final int MAX = 100; // 等价写法:int MAX = 100;
public abstract void add(); // 等价写法：void add();
public abstract float getSum(float x,float y);
}

接口的使用

类通过使用关键字implements声明自己实现一个或多个接口，如果实现多个接口，则用逗号隔开接口名.
class A implements Printable,Addable
class Dog extends Animal implements Eatable,Sleepable
如果一个类实现了某个接口，那么这个类必须重写该接口的所有方法。

理解接口

接口可以增加很多类都需要具有的功能，不同的类可以实现相同的接口，同一个类也可以实现多个接口。
接口只关心操作，并不关心操作的具体实现
接口的思想在于它可以增加很多类都需要具有的功能，而且实现相同的接口类不一定有继承关系。

Test.java


public interface Test {
	
	
	int Max = 100;
	int getSum(int x);

}

Tom.java

public class Tom implements Test {

	@Override
	public int getSum(int x) {
		int Sum = 0;
		
		for (int i= 1; i <= x;i++)
		{
			Sum = Sum + i;
		}
		return Sum;
	}

}

public class Bob  implements Test{

	@Override
	public int getSum(int x) {
		
		return 12 +x;
	}

}

Demo26.java

public class Demo26 {

	public static void main(String[] args) {
		Tom tom = new Tom();
		Bob bob = new Bob();
		
		System.out.println("Tom 计算的结果是:" + tom.getSum(20));
		System.out.println("Bom 计算的结果是:" + bob.getSum(20));

	}

}

接口回调

接口回调是指可以把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中，那么该接口变量就可以调用被类重写的接口方法。

Demo27.java

public class Demo27 {

	public static void main(String[] args) {
		Test test;
		Tom tom = new Tom();
		test = tom;
		System.out.println("Test 计算结果：" + test.getSum(20));
	}

}