Until6
面向对象
1、static关键字
2、Main函数
3、静态什么时候使用
4、静态应用-工具类
5、帮助文档的制作
6、静态代码快
7、对象的初始化过程
8、对象调用成员过程
9、单例设计模式
10、单例设计模式二
static关键字(独自开辟了空间的)
1、Static关键字是用于修饰成员(成员变量、成员函数)
2、修饰成员后,该成员随类的加载而加载--同时,随类的消失而消失
而且修饰的成员优先于对象存在,并且是共享的数据,可直接类名调用。
3、静态是只能静态调用的,而且静态是不能写this、super关键字的!因为是共享数据嘛,所以别想着对象调用。
4、主函数就是静态函数哟
5、被静态修饰的好处:节省空间、方便调用
不好的地方:生命周期长、访问有局限(只能静态访问静态)
静态什么时候使用
当变量是共享数据的时候使用静态,当函数功能是被共有的时候使用静态。
静态应用-工具类
私有化工具类的构造函数,可以避免创建对象而不直接类名调用的情况
帮助文档的制作
/**
@author 作者
@version 版本
*/
/**
......类的介绍
@peram -类的参数接受
@return -返回值
*/
制作帮助文档的代码:doc:javadoc -d myhelp(文件名) -author -version 类名
注意几点:帮助文档的类要Public.私有的方法是不被提取的.构造函数默认权限是和该类相同的
静态代码块
格式:static{}
一样是随着类的加载而加载,只执行一次,用于给类初始化
对象的初始化过程
举例:Person p = new Person();
1、因为new用到了Person.class 所以会先找到Person.class文件并且加载到内存中去
2、执行该类中的static代码块~如果有的话,给person.class类进行初始化
3、在对内存中开辟空间,分配内存地址值
4、在堆内存中建立对象的特有属性,并进行默认初始化
单例设计模式
保证对象的唯一性。
为了避免其它程序过多建立该类对象,先进制其它程序建立该对象。
还为了让其它程序可以访问到该类对象,只好在本类中自定义一个对象
为了其它程序方便访问自定义对象,可以对象提供一些访问方式
步骤:
将构造函数私有化
在类中创建一个本类对象
提供一个方法获取本类对象
public class Simple {
public static void main(String[] args) {
// TODO Auto-generated method stub
}
}
//饿汉式
class Hunger{
private Hunger(){}//私有化构造函数,让别的程序无法建立该类对象
private static Hunger l = new Hunger();//创建一个本类对象,让其它程序可以调用该对象
public static Hunger getHunger()//对象提供获取对象的方法
{
return l;
}
}
//懒汉式
class Lazy{
private Lazy(){}
private static Lazy l=null;
public static Lazy getLazy()
{
if(l==null)
{
synchronized(Lazy.class)
{
if(l==null)
l = new Lazy();
}
}
return l;
}
}
下面再列举后面会接触到模式:
模板设计模式:
在定义功能时,功能的一部分是确定的,但是有一部分是不确定,而确定的部分在使用不确定的部分,那么这时就将不确定的部分暴露出去。由该类的子类去完成。
举个例子:建立了一个计算时间的Time class类,在start和end之间设定一个方法接受不确定的时间!这个方法就为timeCode()方法!然后再定义个一TimeCode类!让该类去继承Time类,并且覆写了里面的timeCode方法!在该方法中输入自己想运行的代码!~其中timeCode方法中的代码就是不确定的因素!~
装饰设计模式:
当想要对已有的对象进行功能增强时,可以定义类,将已有对象传入,基于已有功能,提供加强功能。那么自定义的该类称为装饰类。
后面会有提到!
UNTIL7
面向对象
1、继承的概述
2、聚集关系
3、子父类中变量的特点
4、-------------------------------覆盖
5、子类中构造函数的特点-子类实例化过程
6、Final关键字
7、抽象类
8、抽象类two
9、抽象类练习
10、模版方法模式
11、接口
12、接口的特点
13、借口举例体现
继承的概述
继承要使用到关键字:extends.
继承提高了代码的复用性,使类与类之间产生了关系(也导致了多态的产生)。
继承是必须类与类之间有所关系才能进行继承
组合与聚合
组合和聚合有很大区别,这个区别不是在形式上,而是在本质上:
比如A类中包含B类的一个引用b,当A类的一个对象消亡时,b这个引用所指向的对象也同时消亡(因为没有引用指向它),这种情况叫组合
反之,如果引用b所指向的对象还会有另外的引用指向它,这种情况叫聚合。
实际开发中代码会这样写:
组合:A类的构造方法里创建B类对象。也就是,当A类创建A类对象 时,B类对象随之创建,A类对象消亡,它所包含的B类对象也随之消亡。
聚合:A类对象在创建时不会立即创建B类的对象,而是等待一个外界的对象传给它,传给它的这个对象是A类创建的。
现实生活中的例子:
组合:人与人的手脚;
聚合:人与他的电脑。
Java语言中,值支持单继承(但这是不严谨的,因为有接口的出现,多继承以另一种方式实现了).
但是Java中支持多层继承。
子父类中变量的特点
类中的成员有变量、函数和构造函数。
使用super关键字可以调用父类引用。
继承中子类变量的特点:若子类出现非私有变量,使用This可以调用本类变量,使用super可以调用父类的。
子父类中函数覆盖
有时候子类继承了父类可是函数需要扩展,会对函数进行重写,我们称之为覆盖,类名是和父类一致的,保留了功能定义。而且子类覆盖父类方法,权限必须大于等于父类
子类中构造函数的特点-子类实例化过程
子类继承父类之后,自身构造函数都有一个隐式的super()方法。(因为父类中的数据子类可以直接获取。所以子类对象在建立时,需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时,要先访问一下父类中的构造函数。)
Final关键字
Final关键字修饰类、函数和变量。
被修饰的函数不能覆盖,被修饰的变量只能赋值一次,被修饰的类不能被继承。
抽象类
抽象类要用到关键字abstract
抽象可以修饰类和方法,抽象的对象是不能创建对象的,也就是说不能New
特点:
抽象方法必须在抽象类中,而抽象类中是可以没有抽象方法的
子类继承抽象类要覆写全部方法,如果没有覆盖全,那么子类也是抽象方法
抽象类练习
public class exception {
/**
* 假如我们在开发一个系统时需要对员工进行建模,员工包含3个属性:姓名、工号以及工资
* 经理也是员工,除了含有员工的属性外,另外还有一个奖金属性。请使用继承的思想设计出员工类和经理类
* 要求类中提供必要的方法进行属性访问
*
* 员工类:name id pay
* 经历类:继承了员工,丙有自己特有的bonus
*/
public static void main(String[] args) {
}
}
abstract class Employee{
private String name;
private String id;
private double pay;
Employee(String name,String id,double pay)
{
this.name = name;
this.id = id;
this.pay = pay;
}
public abstract void work();
}
class Manager extends Employee{
private int bonus;
Manager(String name,String id,double pay,int bonus)
{
super(name,id,pay);
this.bonus = bonus;
}
public void work()
{
System.out.print("Manager work");
}
}
class Pro extends Employee{
Pro(String name,String id,double pay)
{
super(name,id,pay);
}
public void work()
{
System.out.print("Pro work");
}
}
总结下:
(1)abstract 关键字,和哪些关键字不能共存。
final:被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类。
private: 抽象类中的私有的抽象方法,不被子类所知,就无法被复写。而抽象方法出现的就是需要被复写。
static:如果static可以修饰抽象方法,那么连对象都省了,直接类名调用就可以了。可是抽象方法运行没意义。
(2)抽象类中是否有构造函数?
有,抽象类是一个父类,要给子类提供实例的初始化。
接口
格式:interface{}
在接口中成员修饰符是固定的:
成员常量:public static final
成员函数:public abstract
类与接口之间的实现方式靠关键字:implements
接口是不可能创建对象的,而且子类全重写之后才可以创建对象,不然子类也还是接口
接口是程序的扩张
接口是对外暴露的规则
接口的特点
接口是对外暴露的规则
接口是程序的功能扩展
接口可以用来多实现
类与接口之间是实现关系,而且类可以继承一个类的同时实现多个接口
接口与接口之间可以有继承关系
public class time {
public static void main(String[] args) {
//记时
long beg = System.currentTimeMillis();
int sum=0;
for(int x = 0;x<1000;x++)
{
sum+=x;
}
System.out.println(sum);
long end = System.currentTimeMillis();
System.out.println(end-beg);
}
}
UNTIL8
面向对象-多态
1、概念
2、扩展性
3、转型
4、示例
5、成员特点
6、主板示例
7、扩展示例
8、Obejct类中的equals()
9、Obejct类中的toString()
概念
多态的理解:多态就像生物学中的分类!父类属于动物,而子类是各种各样的特色动物
A多态的体现:父类引用指向子类对象
B 多态的前提:必须类与类的关系(继承,实现)/存在与覆盖
C 多态的优势:提高程序扩展性
D多态的弊端:只能使用父类的引用访问父类中的成员
示例
public class Duotai {
public static void main(String[] args) {
// 多态的示例
DoStudent ds = new DoStudent();
ds.doSome(new BaseStudent());
ds.doSome(new AdvStudent());
}
}
abstract class Student{
public abstract void study();
public void sleep()
{
System.out.println("睡觉");
}
}
class BaseStudent extends Student
{
public void study()
{
System.out.println("基本班的在学习");
}
public void sleep()
{
System.out.println("基础班的站着睡觉");
}
}
class AdvStudent extends Student{
public void study()
{
System.out.println("高级班的在学习");
}
public void sleep()
{
System.out.println("高级班的躺着睡");
}
}
class DoStudent{
public void doSome(Student stu){
stu.study();
stu.sleep();
}
}
在多态中成员特点
成员函数特点:
在编译时期:参阅引用型变量所属的类中是否有调用方法。如果有,方法通过,没有,编译失败。
在运行时期:参阅对象所属的类中是否有调用方法。
静态成员函数特点:
无论编译或者运行时期,都参考左边的引用型变量。
成员变量特点:
无论编译和运行,都参考左边(引用型变量所属的类)
主板示例
public class Mainb {
public static void main(String[] args) {
// 模拟主板运行示例
MainBoard mb = new MainBoard();
mb.run();
mb.usePCI(new NetCard());
}
}
interface PCI
{
public void open();
public void close();
}
class MainBoard{
public void run()
{
System.out.println("MainBoard run");
}
public void usePCI(PCI p){
if(p!=null)
{
p.open();
p.close();
}
}
}
class NetCard implements PCI{
public void open()
{
System.out.println("NetCard open");
}
public void close()
{
System.out.println("NetCard close");
}
}
Obejct类中的equals()
Public boolean equals(Object obj){}
instanceof
Obejct类中的toString()
Integer.toHex
getClass()
getName()