------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流! ----------
继承,总结:
一.代码块:
1.代码块的种类:
1).局部代码块:定义在某个方法中;
2).成员(构造)代码块:定义在类体中,每次实例化此类对象时被调用;
3).静态代码块:定义在类体中,第一次实例化此类对象时被调用;
2.代码块的作用:
1).跟构造方法一样,用于做一些初始化的操作;
3.如果同时存在静态代码块、构造代码块、构造方法:
静态代码块--->构造代码块--->构造方法;
二.继承:
1.可以将一些相同性质的类中,相同的成员,提取出来,形成一个"概念性的父类"
子类继承了父类,就拥有了父类允许继承的成员。
2.使用关键字:extends
3.继承的特点:
1).只能单继承;
2).允许多级继承;
4.注意事项:
1).父类中的私有成员不能被继承;
2).构造方法不能被继承;
3).不要为了部分功能而去继承;
5.具有 is a 的关系时,可以使用继承;
6.this和super的区别:
1.this指向的本类的对象,可以访问成员变量、成员方法、构造方法
2.super指向的父类的对象,可以访问父类的变量、成员方法、构造方法;
7.继承中构造方法的注意事项:
1.如果父类中有"无参"构造方法时,实例化子类时,JVM会自动调用父类中"无参构造方法"
2.如果父类中没有"无参构造方法"时,子类的构造方法中,必须显示的使用super去调用父类中
带参的构造方法。
8.类的实例化过程:
1.如果有父类,先处理父类:
2.如果有静态成员,先处理静态的;
3.总体过程:
父类静态成员
子类静态成员
父类普通成员变量
父类的构造代码块
父类的构造方法
子类的普通成员变量
子类的构造代码块
子类的构造方法
9.子类成员覆盖父类成员:
1.子类可以定义和父类相同的"成员变量":
this.num:本类的
super.num:父类的
2.子类可以定义和父类相同的方法:叫:方法重写
返回值类型、方法名、形参列表都完全相同;
子类拥有跟父类相同,或更宽的访问修饰符;
3.子类可以覆盖父类的静态方法;
三.fianl关键字:
1.类:表示"最终类",不能被继承;
2.成员变量、局部变量:表示拥有最终的值,其值不能被更改;
3.成员方法:表示最终的方法,不能被重写;
class Phone {
02.
03. // 成员变量
04. private String brand ; // 品牌
05. private String color ; // 颜色
06. private int price ; // 价格
07.
08. // 构造方法
09. public Phone(){}
10.
11. public Phone(String brand , String color , int price){
12. this.brand = brand ;
13. this.color = color ;
14. this.price = price ;
15. }
16.
17. // 提供get和set方法
18. public String getBrand(){
19. return brand ;
20. }
21.
22. public void setBrand(String brand){
23. this.brand = brand ;
24. }
25.
26. public String getColor(){
27. return color ;
28. }
29.
30. public void setColor(String color){
31. this.color = color ;
32. }
33.
34. public int getPrice(){
35. return price ;
36. }
37.
38. public void setPrice(int price){
39. this.price = price ;
40. }
41.
42.}
43.
44.// 测试类
45.class PhoneDemo {
46.
47. public static void main(String[] args){
48.
49. // 创建手机对象方式1
50. Phone p = new Phone();
51.
52. // 给成员变量赋值
53. p.setBrand("苹果");
54. p.setColor("白色");
55. p.setPrice(100);
56.
57. // 获取成员变量
58. System.out.println(p.getBrand() + "---" + p.getColor() + "---" + p.getPrice());
59.
60. System.out.println("----------------------------------");
61.
62. // 创建手机对象方式2
63. Phone p2 = new Phone("三星" , "黑色" , 50);
64.
65. // 获取成员变量
66. System.out.println(p2.getBrand() + "---" + p2.getColor() + "---" + p2.getPrice());
67. }
68.}
多态总结:
一.多态:
1).父类的引用指向了它的子类的对象;(自动的向上转型)
2).使用多态时,访问的成员在父类中必须存在,否则编译错误;
运行时,如果子类成员覆盖父类成员时:
只有普通成员方法运行的是子类的,其它的都是父类的。
3).成员变量:编译看左边,运行看左边;
成员方法:编译看左边,运行看右边;
静态方法:编译看左边,运行看左边;
4).多态时,父类的引用不能访问子类特有的成员;
5).转型的问题:
class A{}
class B extends A{}
class C extends A{}
A.父类引用指向子类对象:自动向上转型;
A a = new B();
B.父类的引用可以强制转换为它所指向的子类的类型;
B b = (B)a;
注意:向下转型,要求必须是父类确实指向了那个子类的对象
如果将a强转为C,会:编译通过,运行时异常:ClassCastException
C c = (C)a;
C.可以使用instanceof关键字,先判断,后转型:
if(a instanceof B){
B b = (B)a;
}
二.抽象类:
1).使用关键字:abstract定义;
2).抽象类的特点:
A.不能被实例化;
B.只能被子类继承;
C.可以包含:
成员变量(静态)
成员方法(静态)
构造方法
抽象方法
3).一个类可以继承自一个抽象类,使用关键字:extends.仍然是单继承;
4).一个类继承了一个抽象类,那么必须全部重写抽象类中的抽象方法。否则,这个子类
也必须是个抽象类。
三.接口:
1).使用关键字:interface定义:
2).接口的特点:
A.不能被实例化;
B.只能用于子类实现。一般子类通过接口来扩展功能。
C.可以包含:
成员变量:必须定义为:public static final(静态常量)
抽象方法:必须定义为:public abstract
3).子类实现:
A.使用关键字:implements
B.一个类可以同时实现多个接口;也可以同时继承自一个父类
class A extends AbstractA implements IA,IB{
}
4).接口和接口之间,是"继承关系",使用extends关键字。而且可以多继承;
匿名内部类:
一.引用类型的形参和返回值:
引用类型的形参:
A.类:实参必须是此类对象的引用,或者是null
B.抽象类:实参必须是此抽象类的子类的对象的引用。或者是null
C.接口:实参必须是此接口的子类的对象的引用。或者是null
引用类型的返回值:
A.类:返回的,必须是此类对象的引用,或者是null;
B.抽象类:返回的,必须是这个抽象类的子类的对象的引用,或者是null;
C.接口:返回的,必须是此接口的子类对象的引用,或者是null.
二.包:
1.定义包:package
2.导入包:import
3.顺序:
1.package
2.import
3.class
4.package必须放在java文件的第一行有效语句;
5.package语句在一个java文件中只能有一条;
6.import语句可以有多条;
7.import语句可以使用通配符*。只统配这个包下的类,通配这个包下的包;
8.怎样使用其它包下的类:
方式一:全名限定:cn.itcast.tools.ArrayTools.getMax();
方式二:先导包,之后就可以直接使用这个类了。
三.访问修饰符:
1.四种:public、protected、(默认)、private
2.修饰类:public 和 (默认)
修饰成员:四种都可以;
3.修饰成员的权限:
1.public :公有,整个项目的所有类都可以访问;
2.protected:受保护的。包内的其它类可以访问。其它包,只有子类可以访问;
3.(默认):包内的其它类可以访问;
4.private:私有:只能在类的内部访问;
四.内部类:
1.成员内部类:
1).同其它成员一样,可以访问外部类中的其它成员;即使是私有的;
2).实例化一个"成员内部类"的对象:
A.B b = new A().new B();
3).成员变量的覆盖:
class A{
int num = 10;
class B{
int num = 20;
void show(){
int num = 30;
System.out.println(num);//30
System.out.println(this.num);//20
System.out.println(A.this.num);//10
}
}
}
2.局部内部类:
1).定义在某个方法或其它局部代码内的内部类;
2).可以获取局部内部类的对象,但此局部内部类,要实现一个外部定义的接口或继承一个父类;
3).注意:局部内部类可以访问局部变量,但是要求这个局部变量必须被声明为:final的(常量)
class A{
int num = 10;
void show(){
int num = 20;
class B{
void f(){
System.out.println("num = " + num);
}
}
}
}
3.匿名内部类:
1).定义在局部;
2).跟局部内部类一样,只是可以省略名字:
interface IA{
void fun();
}
class A{
IA show(){
return new IA(){
public void fun(){
System.out.println("子类重写的fun方法");
}
}
}
}