java 面向对象思想
2015-09-08 22:42
477 查看
1:面向对象的概念,2 : 类和对象的关系,3 : 封装,4 : 构造函数,5 : this关键字,6 : static关键字,
7 : 单例设计模式,8 : 继承,9 : 抽象类,10 : 接口,11 : 多态,12 : Object类,13 : 内部类,
14 : 异常,15 : 包
1:面向对象的概念
理解
a:面向对象是相对面向过程而言
b:面向对象和面向过程都是一种思想
c:面向过程
——强调的是功能行为
d:面向对象
——将功能封装进对象,强调具备了功能的对象。
e:面向对象是基于面向过程的。
面向对象:三个特征:封装(encapsulation),继承(inheritance),多态(polymorphism)
开发:其实就是 找对象,建立对象,使用对象。维护对象的关系。
2:类与对象的关系
类:对现实生活中事物的描述。
对象:这类事物,实实在在存在个体。
在内存中的位置:
成员变量:在堆内存中,因为对象的存在,才在内存中存在。
局部变量:存在栈内存中。
匿名对象
匿名对象使用方式一:对象的方法只调用一次时,可以用匿名对象来完成,这样写比较简化。如果一个对象进行多个成员调用,必须给这个对象起个名字。
匿名对象使用方式二:可以将匿名对象作为实际参数进行传递。
3:封装(Encapsulation)
a:封装:是指隐藏对象的属性和现实细节,仅对外提供公共访问方式。
b:好处:将变化隔离,便于使用,提高重要性,提高安全性
c:封装原则:将不需要对外提供的内容都隐藏起来。把属性都隐藏,提供公共方法对其访问。
之所以对外提供访问方式,就因为可以在访问方式中加入逻辑判断等语句。对访问的数据进行操作。提高代码健壮性。
private :私有,权限修饰符:用于修饰类中的成员(成员变量,成员函数)。 私有只在本类中有效。私有仅仅是封装的一种表现形式。类中的属性通常被私有化,并对外提供公共的访问方法。这样可以避免安全隐患。这个方法一般有两个,规范写法:对于属性 xxx,可以使用setXxx(),getXxx()对其进行操作。
4:构造函数
特点:
a:函数名与类名相同
b:不用定义返回值类型
c:不可以写return语句
作用:给对象进行初始化。
注意:
多个构造函数是以重载的形式存在的,当一个类中没有定义构造函数时,那么系统会默认给该类加入一个空参数的构造函数。当在类中自定义了构造函数后,默认的构造函数就没有了。
构造函数和一般函数在写法上有不同。在运行上也有不同。
构造函数是在对象一建立就运行。给对象初始化。而一般方法是对象调用才执行,是给对象添加对象具备的功能。一个对象建立,构造函数只运行一次。而一般方法可以被该对象调用多次。
什么时候定义构造函数呢?
当分析事物时,该事物存在具备一些特性或者行为,那么将这些内容定义在构造函数中。
构造代码块
作用:给对象进行初始化。对象一建立就运行,而且优先于构造函数执行。
和构造函数的区别:
构造代码块是给所有对象进行统一初始化,而构造函数是给对应的对象初始化。
构造代码块中定义的是不同对象共性的初始化内容。
Person p = new Person();
该句话都做了什么事情?
1,因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。
2,执行该类中的static代码块,如果有的话,给Person.class类进行初始化。
3,在堆内存中开辟空间,分配内存地址。
4,在堆内存中建立对象的特有属性。并进行默认初始化。
5,对属性进行显示初始化。
6,对对象进行构造代码块初始化。
7,对对象进行对应的构造函数初始化。
8,将内存地址付给栈内存中的p变量。
5:this关键字
this代表它所在函数所属对象的引用,哪个对象在调用this所在的函数,this就代表哪个对象。
this的应用:当定义类中功能时,该函数内部要用到调用该函数的对象时,这时用this来表示这个对象。
但凡本类功能内部使用了本类对象,都用this表示。
this语句 :用于构造函数之间进行互相调用。this语句只能定义在构造函数的第一行。因为初始化要先执行。
public static void main(String[] args)
主函数:是一个特殊的函数。作为程序的入口,可以被jvm调用。
主函数的定义:
public:代表着该函数访问权限是最大的。
static:代表主函数随着类的加载就已经存在了。
void:主函数没有具体的返回值。
main:不是关键字,但是是一个特殊的单词,可以被jvm识别。
(String[] arr):函数的参数,参数类型是一个数组,该数组中的元素是字符串。字符串类型的数组。
主函数是固定格式的:jvm识别。
jvm在调用主函数时,传入的是new String[0];
6.static关键字
static关键字:用于修饰成员(成员变量和成员函数)
被修饰后的成员具备以下特点:1:随着类的加载而加载,2:优先于对象存在,3:被所有对象所共享,4:可以直接被类名调用
使用注意:静态方法只能访问静态成员.静态方法中不可以写this,super关键字.主函数是静态的
static用法:是一个修饰符,用于修饰成员(成员变量,成员函数).
当成员被静态修饰后,就多了一个调用方式,除了可以被对象调用外, 还可以直接被类名调用。类名.静态成员。
实例变量和类变量的区别:
1,存放位置。类变量随着类的加载而存在于方法区中。实例变量随着对象的建立而存在于堆内存中。
2,生命周期:类变量生命周期最长,随着类的消失而消失。实例变量生命周期随着对象的消失而消失。
利处:对对象的共享数据进行单独空间的存储,节省空间。没有必要每一个对象中都存储一份。 可以直接被类名调用。
弊端:生命周期过长。 访问出现局限性。(静态虽好,只能访问静态。)
应用:构造函数需要私有化
函数被静态修饰被提供外界使用
静态代码块。
格式:
static{
静态代码块中的执行语句。
}
特点:随着类的加载而执行,只执行一次,并优先于主函数。 用于给类进行初始化的。
静态代码块、构造代码块、构造函数同时存在时的执行顺序:静态代码块——> 构造代码块——>构造函数;
生成Java帮助文档:命令格式:javadoc –df:\ myhelp –auther –version ArrayTool.java
—d当前目录 —df:\存到f:\下 ArrayTool必须public修饰
例: /**
这是一个可以对数组进行操作的工具类,该类中提供了,获取最值,排序等功能。
@author 张三
@version V1.1
*/
public class ArrayTool {
/** 空参数构造函数。 */
private ArrayTool(){}
/** 获取一个整形数组中的最大值。
@param arr 接收一个int类型的数组。
@return 会返回一个该数组中最大值。 */
public static int getMax(int[] arr) {
int max = 0;
for(int x=1; x<arr.length; x++) {
if(arr[x]>arr[max]) max = x;
}
return arr[max];
}
7:单例设计模式
设计模式的分类
总体来说设计模式分为三大类:
创建型模式,共五种:工厂方法模式(Factory Method)、抽象工厂模式(Abstract Factory)、单例模式(Singleton)、建造者模式(Builder)、原型模式(Prototype)。
结构型模式,共七种:适配器模式(Adapter)、装饰器模式(Decorator)、代理模式(Proxy)、外观模式(Facade)、桥接模式(Bridge)、组合模式(Composite)、享元模式(Flyweight)。
行为型模式,共十一种:策略模式(strategy)、模板方法模式(Template Method)、观察者模式(Observer)、迭代子模式(Iterator)、 责任链模式(Chain of Responsibility)、命令模式(Command)、备忘录模式(Memento)、状态模式(State)、访问者模式(Visitor)、中介者模式(Mediator)、解释器模式(Interpreter)。
其实还有两类: 并发型模式和线程池模式。
单例对象(Singleton)是一种常用的设计模式。在Java应用中,单例对象能保证在一个JVM中,该对象只有一个实例存在。
要保证对象唯一
1,为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
2,还为了让其他程序可以访问到该类对象,只好在本类中,自定义一个对象。
3,为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式。
这三部怎么用代码体现呢?
1,将构造函数私有化。
2,在类中创建一个本类对象。
3,提供一个方法可以获取到该对象。
记录原则:定义单例,建议使用饿汉式。
先初始化对象。称为:饿汉式。Single类一进内存,就已经创建好了对象。
class Single{
// 在类中创建一个本类对象
private static Single s = new Single();
// 将构造函数私有化
private Single(){ }
// 提供一个方法可以获取到该对象
public static Single getInstance(){
return s;
}
}
对象是方法被调用时,才初始化,也叫做对象的延时加载。成为:懒汉式。
Single类进内存,对象还没有存在,只有调用了getInstance方法时,才建立对象。
class Single{
private static Single s = null;
private Single(){ }
public static Single getInstance(){
if(s==null){
// 加了一个锁
synchronized(Single.class){
if(s==null)
s = new Single();
}
}
return s;
}
}
8:继承(extends)
继承的特点
1,提高了代码的复用性。
2,让类与类之间产生了关系。有了这个关系,才有了多态的特性。
java支持多层继承。也就是一个继承体系
子父类出现后,类成员的特点:
1,变量
如果子类中出现非私有的同名成员变量时,子类要访问本类中的变量,用this。子类要访问父类中的同名变量,用super。
super关键字
this代表的是本类对象的引用。
super代表的是父类对象的引用。
super()和this()是否可以同时出现的构造函数中。
两个语句只能有一个定义在第一行,所以只能出现其中一个。
super()或者this():为什么一定要定义在第一行?
因为super()或者this()都是调用构造函数,构造函数用于初始化,所以初始化的动作要先完成。
2,子父类中的函数
当子类出现和父类一模一样的函数时,当子类对象调用该函数,会运行子类函数的内容。如同父类的函数被覆盖一样。这种情况是函数的另一个特性:重写(覆盖)。当子类继承父类,沿袭了父类的功能,到子类中,但是子类虽具备该功能,但是功能的内容却和父类不一致,这时,没有必要定义新功能,而是使用覆盖特殊,保留父类的功能定义,并重写功能内容。
覆盖:
1,子类覆盖父类,必须保证子类权限大于等于父类权限,才可以覆盖,否则编译失败。
2,静态只能覆盖静态。
3,子父类中的构造函数
在对子类对象进行初始化时,父类的构造函数也会运行,那是因为子类的构造函数默认第一行有一条隐式的语句
super();。
super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();
为什么子类一定要访问父类中的构造函数
因为父类中的数据子类可以直接获取。所以子类对象在建立时,需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时,要先访问一下父类中的构造函数。如果要访问父类中指定的构造函数,可以通过手动定义super语句的方式来指定。super语句一定定义在子类构造函数的第一行。
子类的实例化过程
子类的所有的构造函数,默认都会访问父类中空参数的构造函数。当父类中没有空参数的构造函数时,子类必须手动通过super语句形式来指定要访问父类中的构造函数。当然:子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。
final关键字最终作为一个修饰符
1,可以修饰类,函数,变量。
2,被final修饰的类不可以被继承。为了避免被继承,被子类复写功能。
3,被final修饰的方法不可以被复写。
4,被final修饰的变量是一个常量只能赋值一次,既可以修饰成员变量,有可以修饰局部变量。当在描述事物时,一些数据的出现值是固定的,那么这时为了增强阅读性,都给这些值起个名字。方便于阅读。而这个值不需要改变,所以加上final修饰。作为常量:常量的书写规范所有字母都大写,如果由多个单词组成。单词间通过_连接。
5,内部类定义在类中的局部位置上是,只能访问该局部被final修饰的局部变量。
9:抽象类 (abstract)
抽象类的特点:
1,抽象方法一定在抽象类中。
2,抽象方法和抽象类都必须被abstract关键字修饰。
3,抽象类不可以用new创建对象。因为调用抽象方法没意义。
4,抽象类中的抽象方法要被使用,必须由子类复写起所有的抽象方法后,建立子类对象调用。如果子类只覆盖了部分抽象方法,那么该子类还是一个抽象类。
抽象类比一般类多个了抽象函数。就是在类中可以定义抽象方法。抽象类不可以实例化。
特殊:抽象类中可以不定义抽象方法,这样做仅仅是不让该类建立对象。
与abstract不能共存的关键字
final:被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类。
private: 抽象类中的私有的抽象方法,不被子类所知,就无法被复写。而抽象方法出现的就是需要被复写。
static:如果static可以修饰抽象方法,那么连对象都省了,直接类名调用就可以了。可是抽象方法运行没意义。
模版方法设计模式
在定义功能时,功能的一部分是确定的,但是有一部分是不确定,而确定的部分在使用不确定的部分,那么这时就将不确定的部分暴露出去。由该类的子类去完成。
10:接口 (interface )
接口:初期理解,可以认为是一个特殊的抽象类,当抽象类中的方法都是抽象的,那么该类可以通过接口的形式来表示。
class用于定义类
interface 用于定义接口。
接口定义时,格式特点:
1,接口中常见定义:常量,抽象方法。
2,接口中的成员都有固定修饰符。
常量:public static final
方法:public abstract
接口中的成员都是public的。
接口的特点:
接口是对外暴露的规则
接口是程序的功能扩展
接口可以用来多实现
类与接口之间是实现关系,而且类可以继承一个类的同时实现多个接口
接口与接口之间可以有继承关系
接口:是不可以创建对象的,因为有抽象方法。需要被子类实现,子类对接口中的抽象方法全都覆盖后,子类才可以实例化。否则子类是一个抽象类。
接口可以被类多实现,也是对多继承不支持的转换形式。java支持多实现。
11:多态
定义:某一类事物的多种存在形态。
1,多态的体现
父类的引用指向了自己的子类对象,也可以接收自己的子类对象。
2,多态的前提
必须是类与类之间有关系。要么继承,要么实现。通常还有一个前提:存在覆盖。
3,多态的好处
多态的出现大大的提高程序的扩展性。
4,多态的弊端:
提高了扩展性,但是只能使用父类的引用访问父类中的成员。
5,多态的应用
equals()
6,多态的出现代码中的特点(多态使用的注意事项)
我们能转换的是父类应用指向了自己的子类对象时,该应用可以被提升,也可以被强制转换。
多态自始至终都是子类对象在做着变化。
instanceof :
用于判断对象的类型。 对象 intanceof 类型(类类型 接口类型)
在多态中成员函数的特点:
在编译时期:参阅引用型变量所属的类中是否有调用的方法。如果有,编译通过,如果没有编译失败。
在运行时期:参阅对象所属的类中是否有调用的方法。
在多态中,成员变量的特点:无论编译和运行,都参考左边(引用型变量所属的类)。
在多态中,静态成员函数的特点:无论编译和运行,都参考做左边。
12.Object类
Object:是所有对象的直接或者间接父类。该类中定义的肯定是所有对象都具备的功能。Object类中已经提供了对对象是否相同的比较方法。如果自定义类中也有比较相同的功能,没有必要重新定义。只要沿袭父类中的功能,建立自己特有比较内容即可。这就是覆盖。
equals方法 指示其他某个对象是否与此对象“相等”
toString方法 返回该对象的字符串表示
13.内部类
将一个类定义在另一个类的里面,对里面那个类就称为内部类(内置类,嵌套类)
内部类的访问规则:
1,内部类可以直接访问外部类中的成员,包括私有。之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用,
格式 外部类名.this
2,外部类要访问内部类,必须建立内部类对象。
访问格式:
①,当内部类定义在外部类的成员位置上,而且非私有,可以在外部其他类中,直接建立内部类对象。
格式
外部类名.内部类名 变量名 = 外部类对象.内部类对象;
Outer.Inner in = new Outer().new Inner();
②,当内部类在成员位置上,就可以被成员修饰符所修饰。
比如,private:将内部类在外部类中进行封装。
内部类具备static的特性。
当内部类被static修饰后,只能直接访问外部类中的static成员。出现了访问局限。
在外部其他类中,如何直接访问static内部类的非静态成员呢?new Outer.Inner().function();
在外部其他类中,如何直接访问static内部类的静态成员呢?Outer.Inner.function();
注意:当内部类中定义了静态成员,该内部类必须是static的。 当外部类中的静态方法访问内部类时,内部类也必须是static的。
内部类定义在局部时,
1,不可以被成员修饰符修饰
2,可以直接访问外部类中的成员,因为还持有外部类中的引用。
但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
匿名内部类:
1,匿名内部类其实就是内部类的简写格式。
2,定义匿名内部类的前提:内部类必须是继承一个类或者实现接口。
3,匿名内部类的格式: new 外部类名或者接口名(){覆盖类或者接口中的代码,(也可以自定义内容。)}
4,其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。
5,匿名内部类中定义的方法最好不要超过3个。
例
interface Inter{
void method();
}
class Test {
//补足代码。通过内部类。
static class Inner implements Inter{
public void method(){
System.out.println("method run");
}
}
static Inter function(){
return new Inner();
}
//补足代码。通过匿名内部类。
static Inter function(){
return new Inter(){
public void method(){
System.out.println("method run");
}
};
}
}
class InnerClassTest {
public static void main(String[] args) {
Test.function().method();
// = Inter
in = Test.function();
// in.method();
Test.function(): //Test类中有一个静态的方法function。
method(): // function这个方法运算后的结果是一个对象。而且是一个Intger类型的对象。
//因为只有是Inter类型的对象,才可以调用method方法。
}
}
例:
匿名内部类:
class InnerClass{
public static void main(String[] args) {
show(new
Inter(){
public void method(){
System.out.println("method show run");
}
}); }是子类代码结束 )是参数结束 ;是这条语句结束
}
public static void show(Inter in){
in.method();
}
}
例:
class InnerTest{
public static void main(String[] args){
new Object() { //new
Object();创建了一个上帝 //new Object(){ }Object的子类对象
public void function(){
}
}.function();
}
}
14.异常
异常:是什么?是对问题的描述。将问题进行对象的封装。
异常的体系
Throwable
|——Error
|——Exception
|——RuntimeException
①Error
通常出现重大问题如:运行的类不存在或者内存溢出等
不缩写针对代码对其处理
②Exception
在运行时运行出现的一起情况,可以通过try catch finally
异常的处理
java 提供了特有的语句进行处理。
try { 需要被检测的代码;}
catch ( 异常类 变量 ) { 处理异常的代码;(处理方式) }
finally { 一定会执行的语句; }
有三个结合格式:
1.try{ }
catch (){ }
2.try{ }
finally{ }
3.try{ }
catch (){ }
finally{ }
注意:
1,finally中定义的通常是 关闭资源代码。因为资源必须释放。
2,finally只有一种情况不会执行。当执行到System.exit(0);fianlly不会执行。
throws关键字,声明该功能有可能会出现问题
throw和throws的用法:
throw定义在函数内,用于抛出异常对象。
throws定义在函数上,用于抛出异常类,可以抛出多个用逗号隔开。
当函数内容有throw抛出异常对象,并未进行try处理。必须要在函数上声明,否则编译失败。
RuntimeException除外。也就说,函数内如果抛出的RuntimeExcpetion异常,函数上可以不用声明。
如果函数声明了异常,调用者需要进行处理。处理方法可以throws可以try。
异常有两种:
编译时被检测异常
该异常在编译时,如果没有处理(没有抛也没有try),编译失败。
该异常被标识,代表这可以被处理。
运行时异常(编译时不检测)
在编译时,不需要处理,编译器不检查。
该异常的发生,建议不处理,让程序停止。需要对代码进行修正。
对捕获到的异常对象进行常见方法操作。
String getMessage():获取异常信息。
toString() //
异常名称 : 异常信息。
printStackTrace()
//异常名称,异常信息,异常出现的位置。
//其实jvm默认的异常处理机制,就是在调用printStackTrace方法。
//打印异常的堆栈的跟踪信息。
对多异常的处理。
1,声明异常时,建议声明更为具体的异常。这样处理的可以更具体。
2,对方声明几个异常,就对应有几个catch块。不要定义多余的catch块。如果多个catch块中的异常出现继承关系,父类异常catch块放在最下面。在进行catch处理时,catch中一定要定义具体处理方式。也不要简单的就书写一条输出语句。
自定义异常:
定义类继承Exception或者RuntimeException
1,为了让该自定义类具备可抛性。
2,让该类具备操作异常的共性方法。
当要定义自定义异常的信息时,可以使用父类已经定义好的功能。
异常异常信息传递给父类的构造函数。
class MyException extends Exception{
MyException(String message){
super(message);
}
}
自定义异常:按照java的面向对象思想,将程序中出现的特有问题进行封装。
异常的好处:
1,将问题进行封装。
2,将正常流程代码和问题处理代码相分离,方便于阅读。
异常的处理原则:
1,处理方式有两种:try 或者 throws。
2,调用到抛出异常的功能时,抛出几个,就处理几个。一个try对应多个catch。
3,多个catch,父类的catch放到最下面。
4,catch内,需要定义针对性的处理方式。不要简单的定义printStackTrace,输出语句。也不要不写。当捕获到的异常,本功能处理不了时,可以继续在catch中抛出。
try{
throw new AException();
}
catch (AException e){
throw e;
}
如果该异常处理不了,但并不属于该功能出现的异常。可以将异常转换后,在抛出和该功能相关的异常。或者异常可以处理,当需要将异常产生的和本功能相关的问题提供出去,让调用者知道,并处理。也可以将捕获异常处理后,转换新的异常。
try{
throw new AException();
}
catch (AException e){
// 对AException处理。
throw new BException();
}
异常的注意事项:
在子父类覆盖时:
1,子类抛出的异常必须是父类的异常的子类或者子集。
2,如果父类或者接口没有异常抛出时,子类覆盖出现异常,只能try不能抛。
15.包 (package)
①对类文件进行分类管理
②给类提供多层命名空间
③写在程序文件的第一行
④类名的全称是 包名.类名
⑤包也是一种封装形式
为了简化类名的书写,使用一个关键字,import.
建议,不要写通配符 * ,需要用到包中的哪个类,就导入哪个类。
总结:
包与包之间进行访问,被访问的包中的类以及类中的成员,需要public修饰。
不同包中的子类还可以直接访问父类中被protected权限修饰的成员。
包与包之间可以使用的权限只有两种,public protected(保护)。
( 权限) public protected default
private
同一个类中 ok ok ok ok
同一个包中 ok ok ok
子类 ok
ok
不同包中 ok
常见包:
java.lang : java的核心包 jdk1.2版本以后,该包中的类自动导入。
java.awt: 用于制作图形界面。
java.io: 用于操作设备上的数据。
java.util : 这里定义是java的工具类。集合,日期。
java.net:用于网络通讯的。
jar 包
7 : 单例设计模式,8 : 继承,9 : 抽象类,10 : 接口,11 : 多态,12 : Object类,13 : 内部类,
14 : 异常,15 : 包
1:面向对象的概念
理解
a:面向对象是相对面向过程而言
b:面向对象和面向过程都是一种思想
c:面向过程
——强调的是功能行为
d:面向对象
——将功能封装进对象,强调具备了功能的对象。
e:面向对象是基于面向过程的。
面向对象:三个特征:封装(encapsulation),继承(inheritance),多态(polymorphism)
开发:其实就是 找对象,建立对象,使用对象。维护对象的关系。
2:类与对象的关系
类:对现实生活中事物的描述。
对象:这类事物,实实在在存在个体。
在内存中的位置:
成员变量:在堆内存中,因为对象的存在,才在内存中存在。
局部变量:存在栈内存中。
匿名对象
匿名对象使用方式一:对象的方法只调用一次时,可以用匿名对象来完成,这样写比较简化。如果一个对象进行多个成员调用,必须给这个对象起个名字。
匿名对象使用方式二:可以将匿名对象作为实际参数进行传递。
3:封装(Encapsulation)
a:封装:是指隐藏对象的属性和现实细节,仅对外提供公共访问方式。
b:好处:将变化隔离,便于使用,提高重要性,提高安全性
c:封装原则:将不需要对外提供的内容都隐藏起来。把属性都隐藏,提供公共方法对其访问。
之所以对外提供访问方式,就因为可以在访问方式中加入逻辑判断等语句。对访问的数据进行操作。提高代码健壮性。
private :私有,权限修饰符:用于修饰类中的成员(成员变量,成员函数)。 私有只在本类中有效。私有仅仅是封装的一种表现形式。类中的属性通常被私有化,并对外提供公共的访问方法。这样可以避免安全隐患。这个方法一般有两个,规范写法:对于属性 xxx,可以使用setXxx(),getXxx()对其进行操作。
4:构造函数
特点:
a:函数名与类名相同
b:不用定义返回值类型
c:不可以写return语句
作用:给对象进行初始化。
注意:
多个构造函数是以重载的形式存在的,当一个类中没有定义构造函数时,那么系统会默认给该类加入一个空参数的构造函数。当在类中自定义了构造函数后,默认的构造函数就没有了。
构造函数和一般函数在写法上有不同。在运行上也有不同。
构造函数是在对象一建立就运行。给对象初始化。而一般方法是对象调用才执行,是给对象添加对象具备的功能。一个对象建立,构造函数只运行一次。而一般方法可以被该对象调用多次。
什么时候定义构造函数呢?
当分析事物时,该事物存在具备一些特性或者行为,那么将这些内容定义在构造函数中。
构造代码块
作用:给对象进行初始化。对象一建立就运行,而且优先于构造函数执行。
和构造函数的区别:
构造代码块是给所有对象进行统一初始化,而构造函数是给对应的对象初始化。
构造代码块中定义的是不同对象共性的初始化内容。
Person p = new Person();
该句话都做了什么事情?
1,因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。
2,执行该类中的static代码块,如果有的话,给Person.class类进行初始化。
3,在堆内存中开辟空间,分配内存地址。
4,在堆内存中建立对象的特有属性。并进行默认初始化。
5,对属性进行显示初始化。
6,对对象进行构造代码块初始化。
7,对对象进行对应的构造函数初始化。
8,将内存地址付给栈内存中的p变量。
5:this关键字
this代表它所在函数所属对象的引用,哪个对象在调用this所在的函数,this就代表哪个对象。
this的应用:当定义类中功能时,该函数内部要用到调用该函数的对象时,这时用this来表示这个对象。
但凡本类功能内部使用了本类对象,都用this表示。
this语句 :用于构造函数之间进行互相调用。this语句只能定义在构造函数的第一行。因为初始化要先执行。
public static void main(String[] args)
主函数:是一个特殊的函数。作为程序的入口,可以被jvm调用。
主函数的定义:
public:代表着该函数访问权限是最大的。
static:代表主函数随着类的加载就已经存在了。
void:主函数没有具体的返回值。
main:不是关键字,但是是一个特殊的单词,可以被jvm识别。
(String[] arr):函数的参数,参数类型是一个数组,该数组中的元素是字符串。字符串类型的数组。
主函数是固定格式的:jvm识别。
jvm在调用主函数时,传入的是new String[0];
6.static关键字
static关键字:用于修饰成员(成员变量和成员函数)
被修饰后的成员具备以下特点:1:随着类的加载而加载,2:优先于对象存在,3:被所有对象所共享,4:可以直接被类名调用
使用注意:静态方法只能访问静态成员.静态方法中不可以写this,super关键字.主函数是静态的
static用法:是一个修饰符,用于修饰成员(成员变量,成员函数).
当成员被静态修饰后,就多了一个调用方式,除了可以被对象调用外, 还可以直接被类名调用。类名.静态成员。
实例变量和类变量的区别:
1,存放位置。类变量随着类的加载而存在于方法区中。实例变量随着对象的建立而存在于堆内存中。
2,生命周期:类变量生命周期最长,随着类的消失而消失。实例变量生命周期随着对象的消失而消失。
利处:对对象的共享数据进行单独空间的存储,节省空间。没有必要每一个对象中都存储一份。 可以直接被类名调用。
弊端:生命周期过长。 访问出现局限性。(静态虽好,只能访问静态。)
应用:构造函数需要私有化
函数被静态修饰被提供外界使用
静态代码块。
格式:
static{
静态代码块中的执行语句。
}
特点:随着类的加载而执行,只执行一次,并优先于主函数。 用于给类进行初始化的。
静态代码块、构造代码块、构造函数同时存在时的执行顺序:静态代码块——> 构造代码块——>构造函数;
生成Java帮助文档:命令格式:javadoc –df:\ myhelp –auther –version ArrayTool.java
—d当前目录 —df:\存到f:\下 ArrayTool必须public修饰
例: /**
这是一个可以对数组进行操作的工具类,该类中提供了,获取最值,排序等功能。
@author 张三
@version V1.1
*/
public class ArrayTool {
/** 空参数构造函数。 */
private ArrayTool(){}
/** 获取一个整形数组中的最大值。
@param arr 接收一个int类型的数组。
@return 会返回一个该数组中最大值。 */
public static int getMax(int[] arr) {
int max = 0;
for(int x=1; x<arr.length; x++) {
if(arr[x]>arr[max]) max = x;
}
return arr[max];
}
7:单例设计模式
设计模式的分类
总体来说设计模式分为三大类:
创建型模式,共五种:工厂方法模式(Factory Method)、抽象工厂模式(Abstract Factory)、单例模式(Singleton)、建造者模式(Builder)、原型模式(Prototype)。
结构型模式,共七种:适配器模式(Adapter)、装饰器模式(Decorator)、代理模式(Proxy)、外观模式(Facade)、桥接模式(Bridge)、组合模式(Composite)、享元模式(Flyweight)。
行为型模式,共十一种:策略模式(strategy)、模板方法模式(Template Method)、观察者模式(Observer)、迭代子模式(Iterator)、 责任链模式(Chain of Responsibility)、命令模式(Command)、备忘录模式(Memento)、状态模式(State)、访问者模式(Visitor)、中介者模式(Mediator)、解释器模式(Interpreter)。
其实还有两类: 并发型模式和线程池模式。
单例对象(Singleton)是一种常用的设计模式。在Java应用中,单例对象能保证在一个JVM中,该对象只有一个实例存在。
要保证对象唯一
1,为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
2,还为了让其他程序可以访问到该类对象,只好在本类中,自定义一个对象。
3,为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式。
这三部怎么用代码体现呢?
1,将构造函数私有化。
2,在类中创建一个本类对象。
3,提供一个方法可以获取到该对象。
记录原则:定义单例,建议使用饿汉式。
先初始化对象。称为:饿汉式。Single类一进内存,就已经创建好了对象。
class Single{
// 在类中创建一个本类对象
private static Single s = new Single();
// 将构造函数私有化
private Single(){ }
// 提供一个方法可以获取到该对象
public static Single getInstance(){
return s;
}
}
对象是方法被调用时,才初始化,也叫做对象的延时加载。成为:懒汉式。
Single类进内存,对象还没有存在,只有调用了getInstance方法时,才建立对象。
class Single{
private static Single s = null;
private Single(){ }
public static Single getInstance(){
if(s==null){
// 加了一个锁
synchronized(Single.class){
if(s==null)
s = new Single();
}
}
return s;
}
}
8:继承(extends)
继承的特点
1,提高了代码的复用性。
2,让类与类之间产生了关系。有了这个关系,才有了多态的特性。
java支持多层继承。也就是一个继承体系
子父类出现后,类成员的特点:
1,变量
如果子类中出现非私有的同名成员变量时,子类要访问本类中的变量,用this。子类要访问父类中的同名变量,用super。
super关键字
this代表的是本类对象的引用。
super代表的是父类对象的引用。
super()和this()是否可以同时出现的构造函数中。
两个语句只能有一个定义在第一行,所以只能出现其中一个。
super()或者this():为什么一定要定义在第一行?
因为super()或者this()都是调用构造函数,构造函数用于初始化,所以初始化的动作要先完成。
2,子父类中的函数
当子类出现和父类一模一样的函数时,当子类对象调用该函数,会运行子类函数的内容。如同父类的函数被覆盖一样。这种情况是函数的另一个特性:重写(覆盖)。当子类继承父类,沿袭了父类的功能,到子类中,但是子类虽具备该功能,但是功能的内容却和父类不一致,这时,没有必要定义新功能,而是使用覆盖特殊,保留父类的功能定义,并重写功能内容。
覆盖:
1,子类覆盖父类,必须保证子类权限大于等于父类权限,才可以覆盖,否则编译失败。
2,静态只能覆盖静态。
3,子父类中的构造函数
在对子类对象进行初始化时,父类的构造函数也会运行,那是因为子类的构造函数默认第一行有一条隐式的语句
super();。
super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();
为什么子类一定要访问父类中的构造函数
因为父类中的数据子类可以直接获取。所以子类对象在建立时,需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时,要先访问一下父类中的构造函数。如果要访问父类中指定的构造函数,可以通过手动定义super语句的方式来指定。super语句一定定义在子类构造函数的第一行。
子类的实例化过程
子类的所有的构造函数,默认都会访问父类中空参数的构造函数。当父类中没有空参数的构造函数时,子类必须手动通过super语句形式来指定要访问父类中的构造函数。当然:子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。
final关键字最终作为一个修饰符
1,可以修饰类,函数,变量。
2,被final修饰的类不可以被继承。为了避免被继承,被子类复写功能。
3,被final修饰的方法不可以被复写。
4,被final修饰的变量是一个常量只能赋值一次,既可以修饰成员变量,有可以修饰局部变量。当在描述事物时,一些数据的出现值是固定的,那么这时为了增强阅读性,都给这些值起个名字。方便于阅读。而这个值不需要改变,所以加上final修饰。作为常量:常量的书写规范所有字母都大写,如果由多个单词组成。单词间通过_连接。
5,内部类定义在类中的局部位置上是,只能访问该局部被final修饰的局部变量。
9:抽象类 (abstract)
抽象类的特点:
1,抽象方法一定在抽象类中。
2,抽象方法和抽象类都必须被abstract关键字修饰。
3,抽象类不可以用new创建对象。因为调用抽象方法没意义。
4,抽象类中的抽象方法要被使用,必须由子类复写起所有的抽象方法后,建立子类对象调用。如果子类只覆盖了部分抽象方法,那么该子类还是一个抽象类。
抽象类比一般类多个了抽象函数。就是在类中可以定义抽象方法。抽象类不可以实例化。
特殊:抽象类中可以不定义抽象方法,这样做仅仅是不让该类建立对象。
与abstract不能共存的关键字
final:被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类。
private: 抽象类中的私有的抽象方法,不被子类所知,就无法被复写。而抽象方法出现的就是需要被复写。
static:如果static可以修饰抽象方法,那么连对象都省了,直接类名调用就可以了。可是抽象方法运行没意义。
模版方法设计模式
在定义功能时,功能的一部分是确定的,但是有一部分是不确定,而确定的部分在使用不确定的部分,那么这时就将不确定的部分暴露出去。由该类的子类去完成。
10:接口 (interface )
接口:初期理解,可以认为是一个特殊的抽象类,当抽象类中的方法都是抽象的,那么该类可以通过接口的形式来表示。
class用于定义类
interface 用于定义接口。
接口定义时,格式特点:
1,接口中常见定义:常量,抽象方法。
2,接口中的成员都有固定修饰符。
常量:public static final
方法:public abstract
接口中的成员都是public的。
接口的特点:
接口是对外暴露的规则
接口是程序的功能扩展
接口可以用来多实现
类与接口之间是实现关系,而且类可以继承一个类的同时实现多个接口
接口与接口之间可以有继承关系
接口:是不可以创建对象的,因为有抽象方法。需要被子类实现,子类对接口中的抽象方法全都覆盖后,子类才可以实例化。否则子类是一个抽象类。
接口可以被类多实现,也是对多继承不支持的转换形式。java支持多实现。
11:多态
定义:某一类事物的多种存在形态。
1,多态的体现
父类的引用指向了自己的子类对象,也可以接收自己的子类对象。
2,多态的前提
必须是类与类之间有关系。要么继承,要么实现。通常还有一个前提:存在覆盖。
3,多态的好处
多态的出现大大的提高程序的扩展性。
4,多态的弊端:
提高了扩展性,但是只能使用父类的引用访问父类中的成员。
5,多态的应用
equals()
6,多态的出现代码中的特点(多态使用的注意事项)
我们能转换的是父类应用指向了自己的子类对象时,该应用可以被提升,也可以被强制转换。
多态自始至终都是子类对象在做着变化。
instanceof :
用于判断对象的类型。 对象 intanceof 类型(类类型 接口类型)
在多态中成员函数的特点:
在编译时期:参阅引用型变量所属的类中是否有调用的方法。如果有,编译通过,如果没有编译失败。
在运行时期:参阅对象所属的类中是否有调用的方法。
在多态中,成员变量的特点:无论编译和运行,都参考左边(引用型变量所属的类)。
在多态中,静态成员函数的特点:无论编译和运行,都参考做左边。
12.Object类
Object:是所有对象的直接或者间接父类。该类中定义的肯定是所有对象都具备的功能。Object类中已经提供了对对象是否相同的比较方法。如果自定义类中也有比较相同的功能,没有必要重新定义。只要沿袭父类中的功能,建立自己特有比较内容即可。这就是覆盖。
equals方法 指示其他某个对象是否与此对象“相等”
toString方法 返回该对象的字符串表示
13.内部类
将一个类定义在另一个类的里面,对里面那个类就称为内部类(内置类,嵌套类)
内部类的访问规则:
1,内部类可以直接访问外部类中的成员,包括私有。之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用,
格式 外部类名.this
2,外部类要访问内部类,必须建立内部类对象。
访问格式:
①,当内部类定义在外部类的成员位置上,而且非私有,可以在外部其他类中,直接建立内部类对象。
格式
外部类名.内部类名 变量名 = 外部类对象.内部类对象;
Outer.Inner in = new Outer().new Inner();
②,当内部类在成员位置上,就可以被成员修饰符所修饰。
比如,private:将内部类在外部类中进行封装。
内部类具备static的特性。
当内部类被static修饰后,只能直接访问外部类中的static成员。出现了访问局限。
在外部其他类中,如何直接访问static内部类的非静态成员呢?new Outer.Inner().function();
在外部其他类中,如何直接访问static内部类的静态成员呢?Outer.Inner.function();
注意:当内部类中定义了静态成员,该内部类必须是static的。 当外部类中的静态方法访问内部类时,内部类也必须是static的。
内部类定义在局部时,
1,不可以被成员修饰符修饰
2,可以直接访问外部类中的成员,因为还持有外部类中的引用。
但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
匿名内部类:
1,匿名内部类其实就是内部类的简写格式。
2,定义匿名内部类的前提:内部类必须是继承一个类或者实现接口。
3,匿名内部类的格式: new 外部类名或者接口名(){覆盖类或者接口中的代码,(也可以自定义内容。)}
4,其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。
5,匿名内部类中定义的方法最好不要超过3个。
例
interface Inter{
void method();
}
class Test {
//补足代码。通过内部类。
static class Inner implements Inter{
public void method(){
System.out.println("method run");
}
}
static Inter function(){
return new Inner();
}
//补足代码。通过匿名内部类。
static Inter function(){
return new Inter(){
public void method(){
System.out.println("method run");
}
};
}
}
class InnerClassTest {
public static void main(String[] args) {
Test.function().method();
// = Inter
in = Test.function();
// in.method();
Test.function(): //Test类中有一个静态的方法function。
method(): // function这个方法运算后的结果是一个对象。而且是一个Intger类型的对象。
//因为只有是Inter类型的对象,才可以调用method方法。
}
}
例:
匿名内部类:
class InnerClass{
public static void main(String[] args) {
show(new
Inter(){
public void method(){
System.out.println("method show run");
}
}); }是子类代码结束 )是参数结束 ;是这条语句结束
}
public static void show(Inter in){
in.method();
}
}
例:
class InnerTest{
public static void main(String[] args){
new Object() { //new
Object();创建了一个上帝 //new Object(){ }Object的子类对象
public void function(){
}
}.function();
}
}
14.异常
异常:是什么?是对问题的描述。将问题进行对象的封装。
异常的体系
Throwable
|——Error
|——Exception
|——RuntimeException
①Error
通常出现重大问题如:运行的类不存在或者内存溢出等
不缩写针对代码对其处理
②Exception
在运行时运行出现的一起情况,可以通过try catch finally
异常的处理
java 提供了特有的语句进行处理。
try { 需要被检测的代码;}
catch ( 异常类 变量 ) { 处理异常的代码;(处理方式) }
finally { 一定会执行的语句; }
有三个结合格式:
1.try{ }
catch (){ }
2.try{ }
finally{ }
3.try{ }
catch (){ }
finally{ }
注意:
1,finally中定义的通常是 关闭资源代码。因为资源必须释放。
2,finally只有一种情况不会执行。当执行到System.exit(0);fianlly不会执行。
throws关键字,声明该功能有可能会出现问题
throw和throws的用法:
throw定义在函数内,用于抛出异常对象。
throws定义在函数上,用于抛出异常类,可以抛出多个用逗号隔开。
当函数内容有throw抛出异常对象,并未进行try处理。必须要在函数上声明,否则编译失败。
RuntimeException除外。也就说,函数内如果抛出的RuntimeExcpetion异常,函数上可以不用声明。
如果函数声明了异常,调用者需要进行处理。处理方法可以throws可以try。
异常有两种:
编译时被检测异常
该异常在编译时,如果没有处理(没有抛也没有try),编译失败。
该异常被标识,代表这可以被处理。
运行时异常(编译时不检测)
在编译时,不需要处理,编译器不检查。
该异常的发生,建议不处理,让程序停止。需要对代码进行修正。
对捕获到的异常对象进行常见方法操作。
String getMessage():获取异常信息。
toString() //
异常名称 : 异常信息。
printStackTrace()
//异常名称,异常信息,异常出现的位置。
//其实jvm默认的异常处理机制,就是在调用printStackTrace方法。
//打印异常的堆栈的跟踪信息。
对多异常的处理。
1,声明异常时,建议声明更为具体的异常。这样处理的可以更具体。
2,对方声明几个异常,就对应有几个catch块。不要定义多余的catch块。如果多个catch块中的异常出现继承关系,父类异常catch块放在最下面。在进行catch处理时,catch中一定要定义具体处理方式。也不要简单的就书写一条输出语句。
自定义异常:
定义类继承Exception或者RuntimeException
1,为了让该自定义类具备可抛性。
2,让该类具备操作异常的共性方法。
当要定义自定义异常的信息时,可以使用父类已经定义好的功能。
异常异常信息传递给父类的构造函数。
class MyException extends Exception{
MyException(String message){
super(message);
}
}
自定义异常:按照java的面向对象思想,将程序中出现的特有问题进行封装。
异常的好处:
1,将问题进行封装。
2,将正常流程代码和问题处理代码相分离,方便于阅读。
异常的处理原则:
1,处理方式有两种:try 或者 throws。
2,调用到抛出异常的功能时,抛出几个,就处理几个。一个try对应多个catch。
3,多个catch,父类的catch放到最下面。
4,catch内,需要定义针对性的处理方式。不要简单的定义printStackTrace,输出语句。也不要不写。当捕获到的异常,本功能处理不了时,可以继续在catch中抛出。
try{
throw new AException();
}
catch (AException e){
throw e;
}
如果该异常处理不了,但并不属于该功能出现的异常。可以将异常转换后,在抛出和该功能相关的异常。或者异常可以处理,当需要将异常产生的和本功能相关的问题提供出去,让调用者知道,并处理。也可以将捕获异常处理后,转换新的异常。
try{
throw new AException();
}
catch (AException e){
// 对AException处理。
throw new BException();
}
异常的注意事项:
在子父类覆盖时:
1,子类抛出的异常必须是父类的异常的子类或者子集。
2,如果父类或者接口没有异常抛出时,子类覆盖出现异常,只能try不能抛。
15.包 (package)
①对类文件进行分类管理
②给类提供多层命名空间
③写在程序文件的第一行
④类名的全称是 包名.类名
⑤包也是一种封装形式
为了简化类名的书写,使用一个关键字,import.
建议,不要写通配符 * ,需要用到包中的哪个类,就导入哪个类。
总结:
包与包之间进行访问,被访问的包中的类以及类中的成员,需要public修饰。
不同包中的子类还可以直接访问父类中被protected权限修饰的成员。
包与包之间可以使用的权限只有两种,public protected(保护)。
( 权限) public protected default
private
同一个类中 ok ok ok ok
同一个包中 ok ok ok
子类 ok
ok
不同包中 ok
常见包:
java.lang : java的核心包 jdk1.2版本以后,该包中的类自动导入。
java.awt: 用于制作图形界面。
java.io: 用于操作设备上的数据。
java.util : 这里定义是java的工具类。集合,日期。
java.net:用于网络通讯的。
jar 包
相关文章推荐
- java String类分析
- java 集合
- JAVA 多线程
- java中的连接池
- 配置NotePad++ 的java 开发环境
- JAVA IO
- JAVA 猜拳游戏三局两胜版
- JAVA中堆和栈的区别
- Jdk5.0泛型
- 拦截器概述和Struts2的运行流程
- Java开发中的23种设计模式详解
- Java中Map相关的快速查找算法
- Struts2的数据校验(Action类必须要继承ActionSupport类)
- struts2自定义类型转换器
- Struts2数据的封装
- 创建java线程方式之三实现Callable接口
- 线程池原理Java
- OpenJDK与HashMap……放心地教这个老家伙一些新(非堆!)技巧
- JAVA Socket地址绑定
- Java集合