java基础整理七（面向对象3）

/*

继承：关键字：extends
提高代码的复用性。
让类与类之间产生了关系，有了这个关系，才有了多态的特性
注意：
不要为了获取其他类的功能，简化代码而继承
必须是类与类之间有所属关系才可以继承。所属关系is a
*/
class person
{
private int age;
private Spring name;
}
class Student extends person //表示继承上面person类的功能
{
private int age ;//person类中含有此功能即可省略
public Spring name;//省略
System.out.println("good studay");
}

class Worker extends person 
{
private int age;//省略
private Spring name;//省略
System.out.println("good work");
}
}
/*
java语言中：java只支持单继承不支持多继承。
因为多继承以带来安全隐患；当多个父类中定义了相同的功能，当功能内容不同时，子类对象不确定要运行哪一个。
但是java保留这种机制，并用另一种体现形式来完成表示：多实现
java支持多层继承：即一个继承体系。
如何使用一个继承体系中的功能呢？
想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性的功能。
通过了解共性功能，就可以知道该体系的基本功能。
那么这个体系已经可以基本使用了。
在具体调用时，要创建子类对象，一是因为父类有可能不能创建对象
二是创建子类对象可以使用更多功能，包括基本的也包括特有的。
简单一句话：查阅父类功能，创建子类对象使用功能。


子父类出现后，类成员的特点：
类中成员：
1，变量：如果子父类中出现非私有的同名成员变量时，子类要访问本类中的变量用this
要访问父类中的变量用super。super的使用和this的使用几乎一致。this代表的是本类对象的引用。
super代表的是父类对象的引用。
*/
class fu
{
int num =4;
}
class zi extends fu
{
//int num =5;
void show()
{
System.out.print(super.num);
}
}
class SevenDay
{
public static void main(Spring[]args)
{
zi z =new zi();
//System.out.println(z.num+","+z.num);
}
}
/*2，函数：子父类中的函数。
当子类出现和父类一模一样的函数时，子类对象调用该函数，会运行子类函数的内容。
如同父类的函数被覆盖一样。
这种情况是函数的另一个特性：重写(覆盖)
当子类继承父类，沿袭了父类的功能到子类中，但子类虽具备该功能功能内容却和父类不一致
这时不用定义新功能，使用覆盖特性，保留父类的功能定义，并重写功能内容
*/
class fu
{
void show()
{
System.out.println("fu show");
}
}
class zi extends fu
{
void show()
{
System.out.println("zi show");
}
}
class Extendstext
{
public static void main(Spring[]args)
{
zi z =new zi();
z.show();
}
}


重写(覆盖)实例 class Tel//电话来电显示工能升级
{
void show ()
{
System.out.println("numbuder");
}
}
class NewTel extends Tel
{
void show()
{
super.show();
System.out.println("name");
System.out.println("pic");
}
}
/*覆盖注意：
1,子类覆盖父类，必须保证子类权限大于等于父类权限才可以覆盖，否则编译失败
2，静态只能覆盖静态。


三，构造函数中子父类不存在覆盖
this()调用本类构造函数
super()调用父类构造函数
在子类对象进行初始化时父类构造函数也会运行那是因为子类的构造函数默认的一行
有一条隐藏的语句 super();且子类中所有构造函数默认第一行都是super();


为什么子类一定要访问父类中的构造函数
因为父类中的数据子类可以直接获取，所以子类对象建立时，需要先查看父类是如何
对这些数据进行初始化的。所以子类对象初始化时要先访问一下父类中的构造函数
如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定
super语句一定在子类构造函数第一行
结论：子类所有的构造函数默认都会访问父类中空参数的构造函数
因为子类每一个构造函数的第一行都有一句隐式的super();
当父类中没有空参数的构造函数时，子类必须手动通过super语句形式
来指定访问父类的构造函数。当然：也可以手动指定this语句来访问本类中的构造函数
子类中至少会有一个构造函数访问父类中的构造函数。this super不能在同一行。
*/
class person
{
Spring name;
person(Spring name)
{
this.name =name;
}
void show(){}
}
class student extends person
{
student(Spring name)
{
super(name);//调用构造函数super();
}
}
void method()
{
super.show();//调用一般函数super.函数名();
}
/*
final：最终,作为一个修饰符。
1，可以修饰类，函数，变量
2，被final修饰的类不可以被继承。用final的作用即为避免被继承被复写。
3，被final修饰的方法不可以被复写
4，被final修饰的变量是一个常量只能被赋值一次，既可以修饰成员变量，又可以修饰局部变量。
final int x=3;x就只能为3 不能为别的值。
当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字。
而这个值不需要改变，所以加上final修饰。
常量：常量书写规范所有字母都大写，如果多个单词组成用_链接
5，内部类定义在类中的局部位置上时，只能访问被final修饰的局部变量。


abstract关键字： 抽象 抽象方法必须放在抽象类前。
抽象：看不懂。
抽象类的特点：
1，抽象方法一定定义在抽象类中。
2，抽象方法抽象类都必须被abstract关键字修饰
3，抽象类不可以用new创建对象。英文调用抽象方法没有意义
4，抽象类中的抽象方法要被使用，必须由子类复写其所有的抽象方法后，建立子类对象调用。
如果子类只覆盖了部分抽象方法，那么该类还是一个抽象类。


抽象类和一般类没有太大的不同。
该如何描述事物还如何描述，只是该事物出现一些看不懂的东西。这些不确定的部分
也是该事物的功能需要确定出来但是无法定义主体因此用abstract修饰。
抽象类比一般类多了抽象函数，就是在类中可以定义抽象方法。
抽象类不可以实例化即不能创建对象 不能new。
特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。
练习：开发系统，员工建模，员工属性3个：姓名，工号，工资。经理也是员工，但还有奖金属性


*/
abstract class YuanGong//员工
{
private String name;
private String id;
private double pay;
YUanGong(String name,String id,double pay)
{
this.name = name;
this.id = id;
this.pay = pay;
}
public abstract void work();


}
class Manager extends YuanGong//经理
{
private int bonus;
Manager(String name,String id,double pay,int bonus)
{
super(name,id,pay);
this.bonus = bonus;
}
public void work()
{
System.out.println("manager work");
}
}
class Pro extends YuanGong//普通员工
{
Pro(String name,String id,double pay)
{
super(name,id,pay);
}
public void work()
{
System.out.println("pro work");
}
}
/*练习：获取一段程序运行时间。原理：获取程序开始和结束的时间并相减。
获取时间：System.currentTimeMillis();
代码完成优化后，就可以解决这类问题
这种方式叫做模板方法设计模式。
即：在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在
使用不确定的部分，这时就将不确定的部分暴露出去，由该类的子类去完成。*/
abstract class GetTime
{
public final void getTime()
{
long start = System.currentTimeMillis();
runcods();

long end = System.currentTimeMillis();
System,out.println("毫秒="+(end-start));
}
public abstract void runcods();
/*for (x=0;x<1000 ;x++ )//测试它的运行时间。
{
System.out.print(x);
}
*/
}
class TemplateDome
{
public static void main(String[]args)
{
GetTime gt = new GetTime();
gt.getTime();
}
}
/*
接口：初期理解，可以认为是一个特殊的抽象类，即类中的方法都是抽象的。这时可以通过接口形式来表示
class用于定义类
interface 用于定义接口
接口定义时，格式特点：
1，接口中常见定义：常量，抽象方法。
2，接口中的成员都有固定修饰符。
常量：public static final
方法：public abstract
且成员都是public
接口中都为抽象用不可创建对象，需要被子类实现，子类对接口中的抽象方法完全被覆盖后，子类才能实例化。
implements 实现 关键字
接口可以被类多实现。也是对多继承不支持的转换形式，即多实现。
*/
例： 
interface Inter
{
public static final int NUM=3;//前面的除int外都可省略下行的也是但是一般不省略，增加阅读性。
public abstract void show();
}
interface InterA
{
public abstract void show();
}
class Demo
{
public void function(){}
}


class Test extends Demo implements Inter,InterA//既可以继承又可以多实现
{
public void show(){}
}


//接口可以继承接口
interface A
{
void methodA();
}
interface B extends A
{
void methodB();
}
interface C extends B
{
void methodc();
}
class D extends C
{
public void methodA(){}
public void methodB(){}
public void methodC(){}
}


//接口还可以多继承
class InterfaceDemo
{
public static void main(String[]args)
{
Test t = new Test();
System.out.println(t.Num);
System.out.println(Test.NUM);
System.out.println(Inter.NUM);
}

}