------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流! -------
<继承>
兴趣是学习编程最好的老师
不积跬步,无以至千里
这辈子没办法做太多事情,所以每一件都要做到精彩绝伦。
1.继承:
1).继承可以增加代码复用,我们可以将现有的类中的属性和方法进行进一步抽取,形成一个"父类",同时其它类可以"继承"自这个类,使用关键字:extends。继承之后,子类将拥有可以被继承的成员变量和成员方法。继承的特点:java中只支持单继承,不支持多继承,但是Java中允许"多级继承"。但是不要仅为了获取其他类中某个功能而去继承,类与类之间要有所属( " is a " )关系。继承关系图:
class 学生{
}
class 教师{
}
class 班级{
int 楼层;//自己的属性
String 门牌号;//自己的属性
学生[] stuArray = new 学生[80];//有学员
教师 tea = new 教师();//有教师
}
3.组合关系:
class 硬盘{
}
class 主板{
}
....
class 电脑{//全部都是由其它类对象组成
硬盘 yp = new 硬盘();
主板 zb = new 主板();
...
}
4.依赖关系:
class 学生{
}
class 教师{
}
class 校长{//校长依赖于学生类和教师类,紧"耦合"
void 谈话(学生 stu){
}
void 谈话(教师 tea){
}
}
*/
//人员类
class Personnel
{
private String name;//姓名
String sex;//性别
int age; //年龄
}
class Personnel2 extends Personnel
{
void show(){
System.out.println("大家好,我叫:" + name +
",性别:" + sex +
",年龄:" + age);
}
}
class Student extends Personnel2{
String classNo; //学号
}
class Teacher extends Personnel{
String subject;//学科
}
class Employee{
String dept; //部门
}
class Demo
{
public static void main(String[] args)
{
Student stu = new Student();
stu.name = "张三";
stu.sex = "男";
stu.age = 20;
stu.show();
Teacher tea = new Teacher();
tea.name = "李四";
tea.sex = "女";
tea.age = 18;
//tea.show();
}
}
2.继承后子父类之间成员的关系
1).成员变量
class Fu{
int num = 5;
}
class Zi extends Fu{
int num = 20;
public void show() {
int num = 30;
System.out.println("num:"+num);
//当局部变量和成员变量重名的时候用this来区分
System.out.println("this num:"+this.num);
//当子类和父类出现了同名变量,用super来区分
System.out.println("father num:"+super.num);
}
}
2).成员方法
class Fu {
public void show() {
System.out.println("fu show");
}
public void method() {}
}
class Zi extends Fu{
public void show(){
System.out.println("zi show");
}
}
3).子类中存在和父类成员方法同名的这种现象,叫做重写,复写,覆盖。
<final关键字>
1.final表示最终的,可以修饰类、成员变量、成员方法;
当被final修饰的类是最终类,不能被继承,被final修饰的成员变量是拥有最终值,只能被赋值1次,不能被修改,final的非static的变量,可以先声明后赋值,但只能在构造方法中赋值,而且只能被赋值一次,final的static的变量,必须要在声明时赋值;此值在运行时不允许修改。被final修饰的成员方法是最终的方法,不能被重写。
class Const{
public static final double PI = 3.14159;
}
class Personnel{
final int num;
final static int num2 = 20;
Personnel(){
num = 10;
}
String name;
final void say(){
System.out.println("我是传智播客的一员");
}
}
class Student extends Personnel{
//不能重写父类的final方法
/* void say(){
}
*/
}
class Demo
{
public static void main(String[] args)
{
System.out.println(Const.PI);
}
}
<抽象类>
1.抽象类,当一个方法不需要定义方法体,可以只有方法声明,此时,这个方法就是一个抽象方法,
抽象方法,使用关键字:使用abstract关键字修饰,一个类中如果有一个抽象方法,那么这个类必须也被声明为abstract(抽象类),一个类成为抽象类后,意味着:此类不能被实例化;就是用来被继承的;如果一个子类继承一个抽象类后,必须要重写父类的抽象方法。否则,子类也必须是抽象的;子类继承抽象类使用extends关键字,同样只能单继承;一个抽象类可以继承另一个抽象类。
2.模板模式
//抽象类用来定义一个模板;
abstract class A
{
}
abstract class Personnel
{
//一个普通方法,子类会自动继承
//就是一个模板方法
void say(){
System.out.println("我是传智播客的一名" + getType());
}
//让子类去实现的
//基本方法
abstract String getType();
}
class Student extends Personnel
{
//重写父类的getType()
String getType(){
return "学生";
}
}
class Teacher extends Personnel
{
//重写父类的getType();
String getType(){
return "教师";
}
}
class Demo
{
public static void main(String[] args)
{
Student stu = new Student();
stu.say();
Teacher tea = new Teacher();
tea.say();
}
}
3.抽象类中可以有抽象方法,可以有普通方法;也可以有普通的成员变量。然而抽象类中可以不包含抽象方法;也可以什么都不包含;
4.抽象关键字abstract不可以和哪些关键字共存?
1).private :因为一个abstract方法需要被重写,所以不能修饰为private;
2).final:因为一个abstract方法需要被重写。被final修饰的方法是不能被重写的,所以不能同final共存;
3).static:因为一个abstract方法没有方法体。静态方法需要对方法体执行内容分配空间,所以不能同static共存;