类的继承
------- android培训、java培训、期待与您交流！ ----------
/**
功能：继承
将学生和工人的共性描述提取出来，单独进行描述的
继承：
1.提高了代码的复用性
2.让类与类之间产生了关系。有了这个关系，才有了多态的特性。
注意：千万不要为了获取其他类的功能，简化代码而继承
必须是类与类之间有所属关系才可以继承。所属关系 is a。
java语言只支持单继承，不支持多继承【这么说不严谨】因为多继承容易带来安全隐患->当多个父类中定义了相同功能
但功能内容不同时，不确定要运行哪一个
java支持多层继承
想要使用体系，先查阅体系父类的描述，因为父类中定义的事该体系中共性功能
那么在具体调用时，要创建最子类的对象，因为有可能父类不能创建对象，二是创建子类对象可以使用更多的功能，包括基本的也包括特有的
简单一句话就是查阅父类功能，创建子类对象使用功能
*/
class Person
{
String name;
int age;
}
class Studentextends Person
{
void study()
{
System.out.println("好好学习");
}
}
class Workerextends Person
{
void work()
{
System.out.println("好好工作");
}
}
class ExtendDemo
{
public static void main(String[] args)
{
System.out.println("HelloWorld!");
}
}
覆盖
1. 子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败
2. 静态只能覆盖静态（不能覆盖非静态加载先后问题）
3. 访问权限问题： private<空<public
/*
子父类类中成员情况
类中成员：
1.变量
2.函数
3.构造函数
1.看变量
当父类和子类中变量名相同时，或默认为是子类的变量
子类要访问本类中的变量本类中的变量，用this
子类要访问父类中的同名变量，用super。
super的使用和this的使用几乎一致。
this代表的是本类对象的引用。
super代表是父类对象的引用。
2.看函数
当父类和子类中函数名相同时,子类的对象调用该函数，会运行子类函数的内容
如同父类函数被覆盖一样
这种情况是函数的另一种特性：（重写）覆盖
*/
class Fu
{
int num=4;
void show()
{
System.out.println("fushow");
}
void speak()
{
System.out.println("vb");
}
}
class Zi extendsFu
{
int num=5;
void show()
{
System.out.println("zishow");
}
void speak()
{
super.speak();
System.out.println("java");
}
}
class ExtendDemo2
{
public static void main(String[] args)
{
Zi z=new Zi();
//System.out.println(z.num+"....."+z.num);
//z.show1();
z.speak();
}
}
子类实例化过程
/*
3.子父类中的构造函数
在对子类对象进行初始化时，父类的构造函数也会执行
那是因为子类的构造函数第一行有一条隐士语句super（）；
super（）；会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super（）；
为什么子类一定要访问父类中的构造函数。
因为父类中的数据，子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的
所以子类在对象初始化时先访问以下父类和中的构造函数
如果要访问父类中指定的构造函数，可以通过手动定义super的方式来访问
注意：super语句一定定义在子类构造函数的第一行
子类所有构造函数默认都会访问父类中空参数中构造函数，因为子类每一个构造函数都有一个隐士super
当父类中没有空参数的构造函数时，子类必须手动通过super或者this语句形式来指定要访问的构造函数
*/
class Fu
{
Fu()
{
System.out.println("Fu1run");
}
Fu(int x)
{
System.out.println("Fu2run................"+x);
}
}
class Zi extendsFu
{
Zi()
{
System.out.println("Zirun");
}
Zi(int x)
{
super(3);
System.out.println("Zi2run");
}
}
class ExtendDemo3
{
public static void main(String[] args)
{
Zi a=new Zi();
Zi b=new Zi(2);
}
}
Final关键字
final关键字：最终
1，可以修饰类，函数，变量
2，被final修饰的类不能被继承.为了避免被继承，被子类覆写功能
3,被final修饰的方法不可以被覆写
4，被final修饰的变量是一个常量只能赋值一次，就可以修饰成员变量，又可以修饰局部变量
当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字。方便阅读
而这个值不需要改变，所以加上final修饰。作为常量，常量的书写规范所有字母都大写，如果由多个单词组成，
单词间通过下滑线连接如： MY_PI
5，内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。
抽象类
/*
当多个类中出现相同功能，但是功能主题不同，
这是可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体。
抽象：看不懂的类
抽象类的特点：
1，抽象方法一定在抽象类中
2，抽象方法和抽象类都必须被abstract关键字修饰
3，抽象类不可以用new创建对象，因为调用抽象方法没意义
4，抽象类中的方法要被使用，必须由子类复写所有的抽象方法后，建立子类调用对象。
如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类
抽象类共和一般类没有太大的不同，该怎样描述事物就如何描述事物
只不过钙食物中出现一些看不懂的东西，这些不确定的部分也是该功能，需要定一下来。但是无法定义实体
通过抽象方法来表示。
抽象类比一般类多了个抽象函数
抽象类不可以实例化。
就是在类中定义抽象方法。
抽象类不可以实例化
特殊：抽象类中不可以定义抽象方法，这样做仅仅是不让该类建立对象
*/
abstractclass Student
{
abstract void study();
}
//
classBaseStudent extends Student
{
void study()
{
System.out.println("basestudy");
}
}
//
classAdvStudent extends Student
{
void study()
{
System.out.println("advstudy");
}
}
//
classAbstactDemo
{
public static void main(String[] args)
{
System.out.println("HelloWorld!");
}
}
/*
员工类：name id pay
经理类：继承了员工，并有特有的bonus
*/
classEmployee
{
private String name;
private String id;
private double pay;
Employee(String name,String id,doublepay)
{
this.name=name;
this.id=id;
this.pay=pay;
}
public abstract void work();
}
classManager extends Employee
{
private int bonus;
Manager(String name,String id,doublepay,int bonus)
{
super(name,id,pay);
this.bonus=bonus;
}
public void work()
{
System.out.println("managerwork");
}
}
class
{
public static void main(String[] args)
{
System.out.println("HelloWorld!");
}
}
模板方法设计模式
/*
需求：获取一段程序运行的时间。
原理：计时原理(结束-开始)；
获取时间：currentTimeMillis()：返回以毫秒为单位的当前时间
当代吗完成优化后，就可以解决这类问题。
这种方式，模板方法设计模式
在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用
不确定的部分，那么这时，就将不确定的部分暴漏出去，由该类的子类来完成。
*/
abstractclass GetTime
{
public final void getTime()//这个函数要用final修饰，阻止其他人覆写；
{
longstart=System.currentTimeMillis();
runCode();
longend=System.currentTimeMillis();
System.out.println("毫秒："+(end-start)+" ");
}
public abstract void runCode();//这玩意是抽象的
}
classSubTime extends GetTime
{
public void runCode()
{
for(int x=0;x<4000;x++)
{
System.out.print(x+"\t");
}
}
}
class TemplateDemo
{
public static void main(String[] args)
{
//GetTime a=new GetTime();
SubTime a=new SubTime();
a.getTime();
}
}
4.8接口
/*
接口： 初期理解，可以认为是一个特殊的抽象类
当抽象类中的方法都是抽象的，那么该类可以通过接口的方式来表示
class:用于定义类
interface：用于定义接口
接口定义时，格式特点：
1，常量：public static final
2，抽象方法 public abstract
接口中的成员都是public 的
3,接口是用来实现的（implements），接口不能用来创建对象，因为有抽象方法，需要被子类实现，子类对接口中的
抽象方法全都覆盖后，子类才可以创建对象。
4，接口可以被类多实现。也是对多继承不支持的转换形式，java实现多实现
5,类继承类，类实现接口，接口继承接口
/*
接口可以理解为体系外的一种功能扩展，用于扩展其他内容
基本功能定义在类中
扩展功能定义在接口中。
*/
/*classStudent
{
abstract void study();
void sleep()
{
System.out.println("sleep");
}
}
interfaceSmoking//like a
{
void smoke();
}
classZhangsan extends Student implements Smoking//张三吸烟
{
void study()
{
}
public void smoke()
{
}
}
classLisi extends Student//李四不吸烟
{
void study()
{
}
}
*/
abstractclass Sporter
{
abstract void play();
}
interfaceStudy
{
}
classWangwu extends Sporter implements Study
{
}
class InterfaceTest
{
public static void main(String[] args)
{
System.out.println("HelloWorld!");
}
}
扫一扫
1602
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
