您的位置：首页 > 编程语言 > Java开发

Java基础知识小结四（自学）

2015-06-23 18:34 375 查看

面向对象2

对象的初始化过程

Person p = new Person（"zhangsan",20）;
这句话在执行的时候都做了什么？

1.因为new用到了Person.class.所以会先去找到Person.class.文件加载带内存中
2.执行该类中的static代码块，如果有的话，给Person.class类进行初始化
3.在堆内存中开辟空间，分配内存地址
4.在堆内存中建立对象的特有属性，并进行默认初始化
5.对属性进行显示初始化
6.对对象进行构造代码块初始化
7.对对象进行对应的构造函数初始化
8.将内存地址付给栈内存中的p变量

设计模式之单例设计模式之一(饿汉式)

什么是设计模式？
解决某一类问题最行之有效的方法。Java中有23种设计模式。
单例设计模式：保证一个类在内存只存在一个对象。

要想保证事物的对象唯一时，
1.为了避免其他程序过多建立类对象，先禁止其他程序建立该类对象。
解决方法：可以将构造函数私有化。

2.为了让其他程序可以访问到该类对象，可以在该类中提供一个自定义的对象。
解决方法：在该类中创建一个私有化，且被静态修饰的类的对象。

3.为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
解决方法：在该类中提供一个共有的，静态的方法，方便获取到该类的对象。当方法是静态的时候，需要添加两个方法来给静态方法设置值，一个方法是设置值(set),返回值类型其void。另一个方法是获取值(get),返回值类型与成员变量一致

(饿汉式)例子：
class Student
{
private int age;

//静态的构造函数
private Student(){}

//建立私有化且静态的自定义对象
private static Student s = new Stndent();

//静态的且方便其他程序访问的方法
public static Student getStudent()
{
return s;
}

//设置值
public void setStudent()
{
return age;

}
//获取值
public int getStudent ()
{
return age;
}
public static void main(String[] args)
{
Student s1 = Student.getStudent;
Student s2 = Student.getStudent ;
}
}

这个是先初始化对象。single类一进内存，就已经创建好了对象。S就已经被加载进了堆内存中。不管用不用，先创建好对象。开发一般用饿汉式。因为安全且简单。

方法被调用有两种方法：
1.用对象的调用
2.用类名调用。用类名调时，方法必须是静态的才能被类名直接调用。

对象在堆内存中。

记住原则：定义单例，建议使用饿汉式。

单例设计模式之二(懒汉式)

//对象是方法被调用时，才初始化，也叫做对象的延时加载。
//single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。等到用到时才开始创建对象。

(懒汉式)例子：
class Single
{
//创建一个私有且静态的空的对象
private static Single s = null;

//私有且静态的构造函数
private static Single (){}

//当方法被调用时才创建对象
public static Single getInstance()
{
if (s==null)
{
s = new Single();
return s;
}
}

面试比较常见懒汉式。

继承

继承：多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承单独的那个类即可
。多个类可以称为子类，单独这个类称为父类或者超类。

通过extends关键字让类与类之间产生继承关系。
class SubDemo extends Demo{}

继承的优点：
1.继承的出现提高了代码的复用性。
2.继承的出现让类与类之间产生了关系，提供了多态的前提。

注意：
不要仅为了获取其他类中某个功能而去继承。类与类之间要有所属( " is a " )关系才可以继承。

继承的特点;
1，子类可以直接访问父类中的非私有的属性和行为。

2，Java只支持单继承，不支持多继承。就是说一个类只能有一个父类，不可以有多个父类。因为多继承容易带来安全隐患。

3，Java支持多层继承(继承体系)
class A{}
class B extends A{}
class C extends B{}

子父类中成员的特点

子父类出现后，类成员的特点：
类中成员：
1.变量
2.函数
3.构造函数

1.变量
(1)如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量，用this，子类要访问父类中的同名变量，用法super。
(2)super的使用和this的使用几乎一致。this代表的是本类对象的引用，super代表的是父类对象的引用。
(3)当子类出现和父类一模一样的变量时，当子类对象调用该变量，会运行子类变量的内容。相当于省略了this关键字。

例子：
class Fu
{
int num = 4;
}
class Zi extends fu
{
int num = 5;
//父类对象的引用
void show()
{
System.out.println(super.num);
}
}
class jicheng
{

public static void main(String[] args)
{
Zi z = new Zi();
Z.show();
}
} 结果：4

2.函数
(1)当子类出现和父类一模一样的函数时(函数名一致)，当子类对象调用该函数，会运行子类函数的内容。如同父类的函数被覆盖一样。这种情况是函数的另一个特性：重写(覆盖)

例子：
class fu
{
void show()
{
System.out.println("fu show");
}
}
class zi extends fu
{
void show()
{
System.out.println("zi show");
}
}
class jicheng
{

public static void main(String[] args)
{
zi z = new zi();
z.show();
}
} 结果：zi show

(2).当子类继承父类，沿袭了父类的功能。子类虽然具备了该功能，但是功能的内容却和父类不一致，这时，没有必要重新定义新功能。还用父类的功能名称，只把父类的内容改成子类需要的功能就行了。
例子：
class fu
{
void show()
{
System.out.println("fu show");
}
//父类方法
void speak()
{
System.out.println("vb");
}
}
class zi extends fu
{
void show()
{
System.out.println("zi show");
}
//子类方法和父类名称一致
void speak()
{
//功能不一样
System.out.println("java");
}
}
class jicheng2
{

public static void main(String[] args)
{
zi z = new zi();
z.speak();
}
} 结果： Java

覆盖：
1.子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译不通过。
2.静态只能覆盖静态。

注意：
重载：只看同名函数的参数列表。
重写：子父类方法要一模一样。

3.构造函数
1.在对子类对象进行初始化时，父类的构造函数也会运行。那是因为子类的构造函数默认第一行有一条隐式的语句 super();
2.super()：会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();

注意：super语句一定定义在子类构造函数的第一行。

结论：
1. 子类的所有的构造函数，默认都会访问父类中空参数的构造函数。因为子类每一个构造函数内部的第一行都有一句隐式的super()；
2. 当父类中没有空参数的构造函数时，子类必须手动通过super或者this语句来指定要访问的构造函数。

final关键字

final：最终。是一个修饰符。
1，可以修饰类，方法，变量。
2，final修饰的类不可以被继承。
3，final修饰的方法不可以被覆盖。
4，final修饰的变量是一个常量。只能被赋值一次。既可以修饰成员变量也可以修饰局部变量。
5，内部类只能访问被final修饰的局部变量。

抽象类

abstract修饰符，用来修饰类和成员方法。
什么是抽象类？
Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。

抽象类的特点：
1，抽象方法一定在抽象类中。
2，抽象方法和抽象类都必须被abstract关键字修饰。
3，抽象类不可以拥抱new创建对象。因为调用抽象方法没意思。
4，抽象类中的抽象方法要被使用，必须由子类复写所有的抽象方法后，建立子类对象调用。如果子类只覆盖部分抽象方法，那么该子类还是抽象类。

特殊：抽象类中可以定义非抽象方法，这样做仅仅是不让该类建立对象。

什么是抽象方法？
多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。
例如：狼和狗都有吼叫的方法，可是吼叫内容是不一样的。所以抽象出来的犬科虽然有吼叫功能，但是并不明确吼叫的细节。

抽象类练习:
/*
假如我们开发一个对员工进行建模的程序，员工有3个属性；姓名，工号，工资。经理也是员工，除了含有员工的大户型外，另外还有一个奖金属性。请用继承的思想设计员工类和经理类。要求类中提供必要的方法进行属性访问。
*/
class yuangong
{
private String name;
private String id;
private int pay;
yuangong(String name,String id,int pay)
this.name = name;
this.id = id;
this.pay = pay;

public abstract void show();
}
//经理类
class manager extends yuangong
{
private bonus;
maneger(String name,String id,int pay,int bonus)
{
super(name, id, pay);
this.bonus = bonus;
}
public void show()
{
System.out.println("meneger work");
}
}
//普通员工类
class yuangong1 extends yuangong
{
yuangong1(String name,String id,int pay)
{
super( name,id,pay);
}
yuangong1 void show()
{
System.out.println("yuangong1 work");
}
}

{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}

模板方法设计模式：
在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去。由该类的子类去完成

阅读更多

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航

Java基础知识小结 四 （自学）

面向对象2

Java基础知识小结四（自学）