Java学习-part.04

java中的继承

1、继承的概念:
继承是类与类的一种关系,是一中 "is a"的关系。
注:java中的继承是单继承
2、继承的好处
子类拥有父类的所有的属性方法,但是父类中的private修饰符无效
实现代码复用

eg:生活有要是有个好爹,就可以少奋斗几年;如果继承了父亲的权力,那就是官二代
3、语法

1
2
3
4
class  子类 extends 父类 
例:class Dog extends Animal{
....
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
//父类
package com.imooc;

//重庆人
public class ChongQing {
String area = "西南地区"; // 地区
String love = "爱吃辣"; //喜好
String beatiWoman = "美女多"; //美女多
double population = 30000000;//人口
public void work() {
System.out.println("工作使我快乐!");
}
public void shoping() {
System.out.println("重庆人是喜欢购物的");
}
}



//子类
package com.imooc;

public class Xiexiang extends ChongQing {

public void getChongqing() {
System.out.print(area + "有个地方叫重庆,那里的人"+love+",而且" + beatiWoman + ",他们是很喜欢工作的,时常都会说:" );
work();
}

public static void main(String[] args) {
new Xiexiang().getChongqing();
}
}

//运行结果

西南地区有个地方叫重庆,那里的人爱吃辣,而且美女多,他们是很喜欢工作的,时常都会说:工作使我快乐!

方法的重写

1、概念:
如果子类对继承父类的方法不满意,是可以重写父类继承的方法的,当调用方法时会优先调用子类的方法。
2、语法规则

  • 语法规则
  • 返回值类型
  • 参数类型及个数
    都要与父类继承的方法相同,才叫方法的重写。

final关键字

概念:使用final关键字做标识有"最终的"含义。
final可以修饰类、方法、属性和变量

  • final修饰类,则该类不允许被继承
  • final修饰方法,则该方法不允许被覆盖(重写
  • final修饰属性,则该类的属性不会进行隐式的初始化(类的初始化属性必须有值)或是构造方法中赋值(但只能选其一)[就是属性只能赋值一次,不管是构造方法还是main方法都无法再次进行赋值]
  • final修饰变量,则该变量的值只能赋一次值,即为常量

super关键字

super关键字:在对象的内部使用,可以代表父类对象

  • 访问父类的属性: super.love
  • 访问父类的方法: super.work()
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    package com.imooc;

    public class Xiexiang extends ChongQing {
    public void work() {
    System.out.println("被重构之后的输出");
    }

    public void getChongqing() {
    System.out.print(super.area + "有个地方叫重庆,那里的人"+super.love+",而且" + super.beatiWoman + ",他们是很喜欢工作的,时常都会说:" );
    super.work(); //work方法被重写,使用super关键字后指向的是使用的是父类的work方法
    work(); //这种写法默认是重写后的方法
    }

    public static void main(String[] args) {
    new Xiexiang().getChongqing();
    }
    }

super的应用

  • 如果子类的构造方法中没有显示调用父类的构造方法,则系统默认调用父类无参的构造方法。

  • 如果显示的调用构造方法,必须在子类的构造方法的第一行。

  • 如果子类构造方法中既没有显示调用父类的构造方法,而父类又没有无参的构造方法,则会编译出错。

Object类

object类是所有类的父类,如果一个类没有使用extends关键字明确标识继承另外一个类,那么这个类默认继承Object类
object类中的方法,适合所有的子类。

常用的方法:
1、toString() 方法 返回值:字符串
直接输出对象只能是返回哈希码生成的一个对象的内存地址,重写toString()方法能够清晰展现对象的属性值。

2、equals()方法 返回值:bool
比较的是对象的引用是否指向同一块内存地址
一般情况下比较两个对象时比较他的值是否一致,所以要进行重写。

多态 **

概念:对象的多种形态
1、引用的多态
父类的引用可以指向本类的对象
父类的引用可以指向子类的对象

eg:Dog类extends Animal类
Animal obj1 = new Animal();
Animal obj2 = new Dog(); //父类的引用是可以指向子类对象的
//Dog obj3 = new Animal(); //X 这种就是错误的

2、方法多态
创建本类对象时,调用的方法为本类的方法
创建子类对象时,调用的方法为子类重写的方法或者继承的方法。(也就是说,子类里面非继承和重写的方法,是不能调用的

多态中的引用类型转换

1、向上类型转换(隐式/自动类型转换),是小类型到大类型的转换;
2、向下类型转换(强制类型转换),是大类型到小类型;
3、instanceof运算符,来解决引用对象的类型,避免类型转换的安全性问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.imooc;

public class convertType {
public static void main(String[] args) {
Dog dog = new Dog();
Animal animal = dog; //自动类型提升,向上类型转换
Dog dog2 = (Dog)animal; //强制类型转换 向下类型转换 [存在风险]
Cat cat = (Cat)animal; //风险点:编译器不会报错,但是运行时提示没有办法进行转换,Cat类型与Dog类型不一致


//上面的代码都不严谨,可以用到instanceof做检测
if(animal instanceof Cat) { //避免类型转换的安全性问题
Cat cat = (Cat)animal;
}else {
System.out.println("无法进行类型转换");
}
}
}

抽象类 **

1、语法定义:
抽象类前使用abstract关键字修饰,则该类为抽象类

2、应用场景:

  • 在某些情况下,某个父类只是知道其子类应该包含怎样的方法,但无法准确知道这些子类如何实现这些方法;
  • 从多个具有相同特征的类中抽象出一个抽象类,以这个抽象类作为子类的模板,从而避免了子类设计的随意性。

3、作用 *
限制规定子类必须实现某些方法,但是不关注实现细节。

4、使用规则

  • abstract定义抽象类
  • abstract定义抽象方法,只有声明,不需要实现
  • 包含抽象方法的类是抽象类
  • 抽象类中可以包含普通的方法,也可以没有抽象方法
  • 抽象类不能直接创建,可以定义引用变量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
package com.abstracttest;

//图形抽象类
public abstract class Mould {

//面积的实现
public abstract double area(double chang,double kuan);

//周长的实现
public abstract double girth(double chang,double kuan);
}


package com.abstracttest;

//矩形
public class Rectangle extends Mould {

@Override //矩形面积的计算
public double area(double chang, double kuan) {
// TODO Auto-generated method stub
double newArea = chang * kuan; //长*宽
return newArea;
}

@Override //矩形的周长
public double girth(double chang, double kuan) {
// TODO Auto-generated method stub
double newGirth = 2*chang + 2*kuan; //2*长+2*宽
return newGirth;
}
}


package com.abstracttest;
//调用方
public class init {
public static void main(String[] args) {
// TODO Auto-generated method stub
Mould mould = new Rectangle(); //父类引用指向子类对象
double newArea = mould.area(150, 145.55); //求面积
double newGirth = mould.girth(150, 145.55); //求周长
System.out.println("面积为:" + newArea);
System.out.println("周长为:" + newGirth);
}
}

接口 **

1、概述
类是一种具体实现体,而接口定义了某一批类所需要遵守的规范,接口不关心这些类的内部数据,也不关心这些类里方法的实现细节,它只规定这些类里必须提供某些方法。
具有相同的功能,却不是同一个类的情况下,就可以使用接口
2、接口的定义
和类定义不同,定义接口不再使用class关键字,而是使用interface关键字。
3、接口定义的基本语法

1
2
3
4
5
public interface [abstract] 接口名 [extends 父接口1,父接口2 ...]   //可以多继承
{
//零到多个常量定义 ...
//零到多个抽象方法的定义 ...
}

接口就是用来被继承、被实现的,修饰符一般建议用public
注意:不能使用private和protected修饰接口
4、接口的定义
常量
接口中的属性是常量,即使定义时不添加, public static final修饰符,系统也会自动加上。

方法
接口中的方法只能是抽象方法,总是使用,即使定义时不添加public abstract修饰符,系统也会自动加上。

5、使用接口
(1)、一个类可以实现一个或者多个接口,实现接口使用implements关键字。java中一个类只能继承一个父类,是不够灵活的,通过实现多个接口可以做补充。

继承父类实现接口的语法为:

1
2
3
4
5
6
7
[修饰符] class 类名 extends 父类 implements 接口1,接口2 ...
{
类体部分 //1、如果继承了抽象类,需要实现继承的抽象方法;
//2、如果遵守了接口,要实现接口中的抽象方法。

//**继承的抽象类中的方法和接口中的抽象方法都必须先实现。
}

注意:如果要继承父类,继承父类必须在实现接口之前。

根据下图实现接口实例:

实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
【Telphone.java】
package com.phone;

//电话抽象类
public abstract class TelPhone {
//具有发短信功能
public abstract void sendMessage();
//具有打电话功能
public abstract void call();
}

【IPlayGame.java】
package com.phone;
//游戏机 接口
public abstract interface IPlayGame {

//具有玩游戏的功能
public abstract void playGame();
}


【CellPhone.java】
package com.phone;

//以前的手机
public class CellPhone extends TelPhone {

@Override //必须实现发短信功能
public void sendMessage() {
// TODO Auto-generated method stub
System.out.println("老电话是具有发短信的功能");
}

@Override //必须实现打电话功能
public void call() {
// TODO Auto-generated method stub
System.out.println("老电话是具有打电话的功能");
}
}

【SmartPhone.java】
package com.phone;

//现在的智能机
public class SmartPhone extends TelPhone implements IPlayGame {

@Override //智能机具有发短信
public void sendMessage() {
// TODO Auto-generated method stub
System.out.println("新电话是具有发短信的功能");
}

@Override //智能机具有打电话
public void call() {
// TODO Auto-generated method stub
System.out.println("新电话是具有打电话的功能");
}
@Override //智能机还具有玩游戏
public void playGame() {
System.out.println("新电话还具有游戏的功能");
}
}

【init.java】 //出口-运行的地方
package com.phone;

public class init {

public static void main(String[] args) {
// TODO Auto-generated method stub
TelPhone tel1 = new CellPhone();
tel1.call();
tel1.sendMessage();

TelPhone tel2 = new SmartPhone();
tel2.call();
tel2.sendMessage();

SmartPhone tel3 = new SmartPhone();
tel3.playGame();
}
}

(2)、接口在使用过程当中,还经常与匿名内部类配合使用
匿名内部类就是没有名字的内部类,多用于关注实现而不关注实现类的名称。

语法格式:

1
2
3
4
5
Interface i = new Interface(){
public void method(){
System.out.println("匿名内部类实现接口的方式");
}
}

实例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package com.phone;

public class init {

public static void main(String[] args) {
// TODO Auto-generated method stub
TelPhone tel1 = new CellPhone();
tel1.call();
tel1.sendMessage();

TelPhone tel2 = new SmartPhone();
tel2.call();
tel2.sendMessage();

SmartPhone tel3 = new SmartPhone();
tel3.playGame();

//匿名内部类的使用 如下两种方式
//语法第一种
IPlayGame pg = new IPlayGame() {
@Override
public void playGame() {
// TODO Auto-generated method stub
System.out.println("这是匿名内部类的方式实现接口");
}
};
pg.playGame();

//语法第二种
new IPlayGame() {
@Override
public void playGame() {
// TODO Auto-generated method stub
System.out.println("这是匿名内部类的方式实现接口2");
}
}.playGame();
}
}


……..后面的内容更精彩………

谢♪翔 wechat
坚持原创技术分享,您的支持将鼓励我继续创作!
-------------本文结束感谢您的阅读-------------
0%