类的继承:
Java语言每一个类只能继承一个父类。叫做单继承;
extends(继承),
父类的写法;
public class 父类类名 (){
}
子类的写法
public class 子类类名 extends 父类类名;
所有类的构造方法第一行都有一个隐藏的“super();"作用是在执行该构造方法之前调用其父类构造方法
子类重写父类的方法:
返回参数相同方法名相同传入参数相同只有方法体不同
7.1例题
public class Parent{
public Parent(){
System.out.println("调用Child类结构方法");
}
}
public class Child extends Parent {
public Child(){
System.out.print("调用Child类结构方法");
}
}
7.2例题
代码:
public class Telephone {//电话类
String button = "button:0~9";//成员属性,10个按键
void call() {//拨打电话功能
System.out.println("开始拨打电话");
class Mobile extends Telephone{//手机类继承电话类
String screen = "screen.液晶屏";//成员属性,液晶屏幕
}
public class Demo2 { public static void main(String[] args) {
// TODO Auto-generated method stub
Mobile motto =new Mobile();
System.out.print(motto.button);//子类调用父类属性
System.out.print(motto.screen);//子类调用父类没有的属性
motto.call();//子类调用父类方法
}
}
Object类:
所有类都可以继承Object类;
getClass方法是Object类定义的方法,它会返回对象执行的Class实例。
toString方法的功能是将一个对象放回为字符串类型,它会返回一个String实例。
getCess()方法
getClass方法是Object类定义的方法。它会返回对象执行时的 Class实例,然后使用此实例调用Name()方法可以取得类的名称。语法如下,
getclass().getname();
可以将geClas0方法与toSring0方法联合使用。
2. toSming0方法
toSrng0方法的功能是将个对象返回为字符审形式, 它会返回一个String实例。在实际的应用常重写wSring0方法, 为对象提供 个特定的输出模式。 当这个类转换为字符串或与字符串连接
7.3例题
public class Student {
String name;
int age;
public Student(String name,int age) {
this.name = name;
t his.age = age;
}
public String toString() {
return "我叫" + name+", 今年" + age + "岁。";
}
public static void main(String args) {
Student s1 = new Student("张三", 16);
System.out.println(s1);
Student s2 = new Student("李四", 19);
System.out.println(s2);
}
}
7.4例题
public class People {
int id;//身份证号
String name;//名字
public People(int id,String name) {
this.id = id;
this.name =name;
}
public boolean equals(Object obj) {//重写Object类的equals()方法
if(this ==obj)//如果参数与本类是同一个对象
return false;
if(obj ==null)//如果参数是null
return false;
if(getClass()!=obj.getClass())//如果参数与本类类型不同
return false;
People other =(People)obj;//将参数强转成本类对象
if(id!=other.id)//如果两者的身份证号不相等
return false;
return false;
}
public String toString() {//重写Object类的toString()方法
return name;//只输出名字
}
public static void main(String[] args)
{
People p1 =new People(220,"tom");
People p2 =new People(220,"汤姆");
People p3 =new People(330,"张三");
Object o =new Object();
System.out.println(p1+"与"+p2+"是否为同一人?");
System.out.println("equals()方法的结果:"+p1.equals(p2));
System.out.println("==运算符的结果:"+(p1==p2));
System.out.println(); System.out.println(p1+"与"+p3+"是否为同一人?"); System.out.println(p1.equals(p3));
System.out.print(p1+"与"+o+"是否为同一人?");
System.out.println(p1.equals(o));
}
}
对象类型的转换:
向上转型
clone=克隆;
equals=相同;
finalize=相等;
toSteing=
子类对象赋值给父类引用
Animal a = newDog();
自动类型转换
7.5例题
class People{}
class Teacher extends People{}
public class Demo3{
public static void main(String[]args){
People tom = new Teacher();
}
}
向下转型
父类对象赋值给子类引用
Dog a = new Animal( );
7.6例题
class Bird {}
class Pigeon extends Bird{}
public class Demo4{
public static void main(String[] args){
Bird bird = new Pigeon();//某只鸽子是一只鸟
Pigeon pigeon = bird;//某只鸟是一只鸽子
}
使用instanceof关键字判断对象类型:
对象名 instanceof 类名 作用:
判断对象是否属于该类或其子类
7.7例题
class Quadrangle{}
class Squar extends Quadrangle{}
class Circular{}
public class Demo5{
public static void main(String args[]){
Quadrangle q=new Quadrangle();//四边形对象
Square s = new Square();//正方形对象
System.out.println(q instanceof Square);//判断四边形是否为正方形的子类
System.out.println(s instanceof Quadeangle);//判断正方形是否为四边形的子类 System.out.println(q instanceof Circular);//判断正方形是否为圆形的子类
}
}
方法的重载
方法名相同 参数不同
7.8例题
ublic class OverLoadTest {
public static int add(int a, int b){//定义一个方法
return a + b;
}
public static double add(double a, double b){//与第一个方法名称相同,参数类型不同
return a + b;
}
public static int add(int a){//与第一个方法参数个数不同
return a;
} public static int add(int a, double b) {//先int参数,后double参数
return a;//输出int参数
}
public static int add(double a, int b){//先double参数,后int参数
return b;//输出int参数
}
public static void main(String args[]){
System. out .println("调用add(int,int)方法:"+add(1, 2));
System. out .println("调用add(double,double)方法:"+add(2.1,3.3));
System. out .println("调用add(int)方法:"+add(1));
System. out .println("调用add(int,double)方法:"+add(5, 8.0));
System. out .println("调用add(double,int)方法:"+add(5.0, 8));
}
}
返回值 方法名(参数数据类型....参数名称)
7.9例题
public class OverLoadTest2 {
public static int add(int a,int b) {
return a+b;
}
public static double add(double a,double b) {
return a+b;
}
public static int add(int a) {
return a;
}
public static int add(int a,double b) {
return a;
}
public static int add(double a,int b) {
return b;
}
public static int add(int...a) {//定义不定长参数方法
int s =0;
for(int i=0;i<a.length;i++) {//根据参数个数做循环操作
s +=a[i];//将每个参数累加
}
return s;//将计算机结果返回
}
public static void main(String[] args) {
System.out.println("调用add(int,int)方法:"+add(1,2));
System.out.println("调用add(double ,double)方法:"+add(2.1,3.3));
System.out.println("调用add(int)方法:"+add(1));
System.out.println("调用add(int,double)方法:"+add(5,8.0));
System.out.println("调用add(double,int)方法:"+add(5.0,8));
System.out.println("调用不定长数方法:"+ add(1,2,3,4,5,6,7,8,9));
System.out.println("调用不定长数方法:"+ add(1));
}
}
子类重写父类的方法:
返回参数相同 方法名相同 传入参数相同 只有方法体不同
final关键字
final变量:
final修饰变量----不可改变的量(常量)
7.10例题
public class FinalData {
static final double PI = 3.1415926;
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("圆周率的值为:"+PI); System.out.println("半径为3的圆的周长为:"+(2*3*PI));//尝试修改PI的值
PI = 3.1415927;
final方法:
final修饰方法----不可被重写
7.11例题
class Dad {
public final void turnOnTheTV() {
System.out.println("爸爸打开了电视");
}
}
class Baby extends Dad{
public final void turnOnTheTV() {
System.out.println("宝宝也要打开电视");
}
}
final类:
final修饰类----不能被继承
final类无法被继承
final class FinalClass{
}
public class FinalTest extends FinalClass {
}
7.7多态
利用多态可以使程序具有良好的扩展性,并可以对所有类对象进行通用的处理。
假如现在要编写一个绘制图形的方法draw(),如果传入正方形对象将绘制正方形,如果传入圆形对象就绘制圆形,这种场景可以使用重载来实现,定义如下:
public void draw(Square s){
//绘制正方形的方法
}
public void draw(Circular c){
//绘制圆形方法
}
例题7.12
class Shape{} //图形类
class Square extends Shape{} //正方形类继承图形类
class Circular extends Shape{} //圆形类继承图形类
public class Demo6 {
public static void draw(Shape s) { //绘制方法
if(s instanceof Square) { //如果是正方形
System.out.println("绘制正方形");
}else if(s instanceof Circular) { //如果是圆形
System.out.println("绘制圆形")
; }else { //如果是其他类型
System.out.println("绘制父类图形");
}
}
public static void main(String[]args) {
draw(new Shape());
draw(new Square()); draw(new Circular());
}
}
7.8抽象类与接口
7.8.1抽象类
抽象方选没有方法体,这个方法本身没有任何意义,除非它被重写,而承载这个抽象方法的抽象类必须被继系。实际上抽象类除了被继承没有任何意义。定义抽象类的语法如下:
ublic abstract class Parent{
abstract void testAbstract(); //定义抽象方法
}
只要类中有一个抽象方法,此类就被标记为抽象类。
抽象类被继承后需要实现其中所有的抽象方法,也就是保证以相同的方法名称、参数列表和返回值类型创建出非抽象方法,当然也可以是抽象方法。下图说明了抽象类的继承关系
7.8.2接口
接口所有方法都是抽象方法
修饰符inter face 接口名{}
实现implements
java语言每个类可以实现多个接口
修饰符 class 类名 implements 接口1,接口2,接口3,.....{}
接口是抽象类的延伸,可以将它看作是纯粹的抽象类,接口中的所有方法都没有方法体。对于7.8.1节中遗留的问题,可以将draw0方法封装到一个接口中,使需要draw0方法的类实现这个接口,同时也继承图形类,这就是接口存在的必要性。在图7.11中,描述了各个子类继承图形类后使用接口的关系。
接口使用 interface 关键字进行定义,其语法如下
public interface Paintable{
void draw(); //定义接口方法可省略public abstract关键字
}
ublic:接口可以像类一样被权限修饰符修饰,但public关键字仅限于接口在与其同名的文件中被定义。
interface:定义接口关键字。
Paintable:接口名称。
一个类继承一个父类的同时再实现一个接口,可以写成如下形式:
public class Parallelogram extends Quadrangle implements Paaintable{
...
}
例题7.13
interface Paintable{ //可绘制接口
public void draw(); //绘制抽象方法
}
class Quadrangle{
public void doAnything() {
System.out.println("四边形提供的方法");
}
}
//平行四边形类,继承四边形类,并实现了可绘制接口
class Parallelogram extends Quadrangle implements Paintable{
public void draw() { //由于该类实现了接口,所以需要覆盖draw()方法
System.out.println("绘制平行四边形");
}
}
//正方形类,继承四边形类,并实现了可绘制接口
class Square extends Quadrangle implements Paintable{
public void draw() {
System.out.println("绘制正方形");
}
}
//圆形类,仅实现了可绘制接口
class Circular implements Paintable{
public void draw() {
System.out.println("绘制圆形");
}
}
public class Demo7 {
public static void main(String[]args) {
Square s = new Square();
s.draw();
s.doAnything();
Parallelogram p=new Parallelogram();
p.draw();
p.doAnything();
Circular c=new Circular();
c.draw();
}
}
实现多个接口的语法:
class 类名 implements 接口1,接口2,接口3...
一个接口可以继承另一个接口,语法如下:
interface intf1{}
interface intf2 extends intf1{} //接口继承接口