黑马程序员——Java基础---面向对象
来源:互联网 发布:虚拟商品淘宝客服介入 编辑:程序博客网 时间:2024/06/04 18:29
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------
1. 面向对象概念
1.1 概念
面向对象是相对面向过程而言,面向对象和面向过程都是一种思想。
面向过程:强调的是功能行为。代表语言:C语言。例子:把大象装进冰箱
1. 打开冰箱。
2. 存储大象。
3. 关上冰箱。
"打开"、"存储"、"关上"都是功能行为,在代码中的直观体现就是函数或者方法,这就是一种面向过程的以功能行为为主体的思想体现。
面向对象:将功能封装进对象,强调具备了功能的对象。代表语言:Java、C++、C#。
例子:把大象装进冰箱
1. 冰箱打开。
2. 冰箱存储。
3. 冰箱关闭。
可以看到,所有的操作都是以"冰箱"为主体,而不是功能行为。也就是说冰箱自己已经具备"打开"、"存储"、"关上"的行为功能,我们只需要让 冰箱执行它具备的功能就可以了。这就是一种面向对象的以执行功能的对象为主体的思想体现。
1.2 特点
面向对象是一种符合人们思考习惯的思想,可以将复杂的事情简单化,将程序员从执行者转换成了指挥者。
完成需求时:
1. 先要去找具有所需功能的对象来用。
2. 如果该对象不存在,那么创建一个具有所需功能的对象。
这样可以简化开发并提高复用。
完成需求时:
1. 先要去找具有所需功能的对象来用。
2. 如果该对象不存在,那么创建一个具有所需功能的对象。
这样可以简化开发并提高复用。
1.3 开发设计中的特征
开发的过程:
其实就是不断的创建对象,使用对象,指挥对象做事情。
设计的过程:
其实就是在管理和维护对象之间的关系。
面向对象的特征:
封装(encapsulation)
继承(inheritance)
多态(polymorphism)
其实就是不断的创建对象,使用对象,指挥对象做事情。
设计的过程:
其实就是在管理和维护对象之间的关系。
面向对象的特征:
封装(encapsulation)
继承(inheritance)
多态(polymorphism)
2. 类与对象的关系
使用计算机语言就是不断地在描述现实生活中的事物。
java中描述事物通过类的形式体现,类是具体事物的抽象,概念上的定义。
对象即是该类事物实实在在存在的个体。
java中描述事物通过类的形式体现,类是具体事物的抽象,概念上的定义。
对象即是该类事物实实在在存在的个体。
2.1 类与对象比喻
可以理解为:类就是图纸,汽车就是堆内存中的对象。
对于同一类事物可以抽取它们的共性的内容,定义在类中。如:生活中的汽车,每一台车都有轮胎数和颜色。
那么在通过java描述汽车这类事物时,就可以将这两个共性属性作为类中的属性进行定义。
通过该类建立的每一个汽车实体都具有该属性,并可以有对象特有的属性值。
对于同一类事物可以抽取它们的共性的内容,定义在类中。如:生活中的汽车,每一台车都有轮胎数和颜色。
那么在通过java描述汽车这类事物时,就可以将这两个共性属性作为类中的属性进行定义。
通过该类建立的每一个汽车实体都具有该属性,并可以有对象特有的属性值。
2.3 类的定义
生活中描述事物无非就是描述事物的属性和行为。如:人有身高,体重等属性,有说话,打球等行为。
Java中用类class来描述事物也是如此。
属性:对应类中的成员变量。
行为:对应类中的成员函数。
定义类其实在定义类中的成员(成员变量和成员函数)。
Java中用类class来描述事物也是如此。
属性:对应类中的成员变量。
行为:对应类中的成员函数。
定义类其实在定义类中的成员(成员变量和成员函数)。
2.4 成员变量和局部变量
成员变量:
1. 成员变量定义在类中,在整个类中都可以被访问。
2. 成员变量随着对象的建立而建立,随着对象的消失而消失,存在于对象所在的堆内存中。
3. 成员变量有默认初始化值。
局部变量:
1. 局部变量只定义在局部范围内,如:函数内,语句内等,只在所属的区域有效。
2. 局部变量存在于栈内存中,作用的范围结束,变量空间会自动释放。
3. 局部变量没有默认初始化值。
1. 成员变量定义在类中,在整个类中都可以被访问。
2. 成员变量随着对象的建立而建立,随着对象的消失而消失,存在于对象所在的堆内存中。
3. 成员变量有默认初始化值。
局部变量:
1. 局部变量只定义在局部范围内,如:函数内,语句内等,只在所属的区域有效。
2. 局部变量存在于栈内存中,作用的范围结束,变量空间会自动释放。
3. 局部变量没有默认初始化值。
2.5 创建和使用对象
java中通过new关键字来创建对象
/** 描述小汽车* 分析:* 1. 属性:* 轮胎数* 颜色* 2. 行为* 移动* 定义类其实就是在定义类中的成员。* 成员:成员变量<-->属性,成员函数<-->行为。*///对Car这类事物进行描述class Car{ //成员变量 String color = "red"; int num = 4; //成员方法,移动 void show() { //临时变量 int num = 10; //输出临时变量的值 System. out.println("color = " +color +"...num = " +num); }}class CarDemo{ public static void main(String[] args) { //通过new关键字,建立对象 //c就是一个类类型的引用变量,指向了该类的对象 Car c = new Car(); //对对象的属性进行修改 c. color = "black" ; //输出成员变量的默认值 System. out.println(c.num); //通过对象.成员的形式来使用对象的功能 c.show(); }}
2.6 对象的内存结构
示例:Car c1 = new Car();
c1.color="blue";
Car c2 = new Car();
内存结构示意图:
只要是用new操作符定义的实体就会在堆内存中开辟一个新的空间,并且每一个对象中都有一份属于自己的属性。
通过(对象 .)对象成员的方式操作对象中的成员,对其中一个对象的成员进行了修改,和另一个对象没有任何关系。
需要提到的是c1、c2都是对实体的引用变量,如果执行c2 = c1,那么c2也就指向了c1引用的实体。c2原来引用的实体因为没 有被引用变量引用,就会被垃圾回收器回收。
2.7 匿名对象
匿名对象是对象的简化形式。
匿名对象两种使用情况:
匿名对象两种使用情况:
1. 当对对象方法仅进行一次调用时;
2. 匿名对象可以作为实际参数进行传递。
示例:
class Car{ String color = "red"; int num = 4; public static void run() { System.out.println("function run is running!" ); }}class CarDemo{ public static void main(String[] args){ //对对象方法仅进行一次调用时,就可以使用匿名对象 new Car().run(); //匿名对象可以作为实际参数进行传递 show(new Car()); } public static void show(Car c){ c. num = 3; c. color = "black" ; System.out.println("function show is running!" ); System.out.println(c.num + "..." + c. color); }}
2.8.1 基本数据类型参数
//基本数据类型参数传递class Demo{ public static void main(String[] args){
//定义int型数据变量x
<span style="line-height: 30.7999992370605px;"> </span><span style="font-family: SimSun; line-height: 30.7999992370605px;">int x = 3;</span>
show(x); System.out.println("x=" + x); } public static void show(int x)
{ x = 4; }}
执行过程说明:
1、jvm调用main方法,main方法入栈。
2、将x变量值设置为3。
3、main方法调用show方法,3作为基本数据类型参数赋值给show方法参数x,也就是说,此时show方法的参数x值为3。
4、show方法执行x=4后,show方法的参数x值变为4。
5、show方法执行结束,show方法出栈。show方法参数x也随之出栈。
6、main方法打印x的值。此时x指的是main方法中的x变量的值(show方法中的参数x已经随show方法一块出栈了)。所以,打印出来的x值为3而 不是4。
7、main方法执行结束,出栈。
2.8.2 引用数据类型参数
class Demo{ int x = 3; public static void main(String[] args)
{
//定义引用数据类型 Demo d = new Demo(); d.x = 9;
//这里d是一个引用数据类型,它只向了一个对象。 show(d); System.out.println(d.x); } public static void show(Demo d)
{ d.x = 4; }}
执行过程说明:
1、jvm调用main方法,main方法入栈。
2、创建Demo对象d(在堆内存中创建,d作为引用变量,指向堆内存中创建的实体对象),并将d指向的实体对象中的属性x的值设置为9。
3、main方法调用show方法,d作为引用数据类型参数赋值给show方法参数d,也就是说,此时show方法的参数d和main方法中的变量d同时指向了 堆内存中同一个实体对象。
4、show方法执行d.x=4后,堆内存中的实体对象的x属性值变为4。
5、show方法执行结束,show方法出栈,show方法参数d也随之出栈。虽然show方法参数d出栈了,但是,由于main方法的变量d依然引用着堆内存 中的实体对象,因此堆内存中的实体对象不会被垃圾回收器清除。
6、main方法打印d.x的值。此时,d指的是main方法中的引用变量x,d.x指的依然是堆内存中的实体对象中x的值。所以,打印出来的值为4而不 是9。
7、main方法执行结束,出栈。
在java中,方法参数的传递永远都是传值,而这个值,对于基本数据类型,值就是你赋给变量的那个值。而对于引用数据类型,这个值是对 象的引用,而不是这个对象本身。
3. 封装
封装:是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。
好处:
1. 将变化隔离。
2. 便于使用。
3. 提高重用性。
4. 提高安全性。
封装原则:
1. 将不需要对外提供的内容都隐藏起来。
2. 把属性都隐藏,提供公共方法对其访问。如,getXXX,setXXX。
示例:好处:
1. 将变化隔离。
2. 便于使用。
3. 提高重用性。
4. 提高安全性。
封装原则:
1. 将不需要对外提供的内容都隐藏起来。
2. 把属性都隐藏,提供公共方法对其访问。如,getXXX,setXXX。
/** * 需求:演示封装特性,定义一个人对象,将人的姓名年龄属性分装。 * 思路:成员参数私有化,对外提供公共方法来修改私有成员变量。 * @author jinlong * */package com.blog.part2.对象;class Person{//通过私有化把属性进行隐藏private String name;private int age;//构造函数初始化成员变量值Person(String name,int age){this.setName(name);this.setAge(age);}//对外提供get,set方法,用来修改和获取name,age值public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {//在set方法内还可以对属性的赋值进行限制if(age<130&&age>0) this.age = age;elseSystem.out.println("年龄赋值不符合常识!");}}public class PersonDemo {public static void main(String[] args){//定义一个对象p1,Person p1 = new Person("zhangsan",20); //通过get set方法访问 System.out.println("姓名:"+p1.getName()+" 年龄:"+p1.getAge()); //赋值不合法,set方法就不允许成功赋值 p1.setAge(300); //打印 System.out.println("姓名:"+p1.getName()+" 年龄:"+p1.getAge()); }}运行结果:
1、私有仅仅是封装的一种体现而已。
2、private关键字:是一个权限修饰符,用于修饰成员(成员变量和成员函数),被私有化的成员只在本类中有效。
3、常用场景之一:将成员变量私有化,对外提供对应的set、get方法对其进行访问,提高对数据访问的安全性。
4. 构造函数
4.1 特点:
1、函数名与类名相同。
2、不用定义返回值类型。
3、没有具体的返回值。
2、不用定义返回值类型。
3、没有具体的返回值。
作用:给对象进行初始化。
2、创建对象都必须要通过构造函数初始化。
一个类中如果没有定义过构造函数,那么该类中会有一个默认的空参数构造函数。
如果在类中定义了指定的构造函数,那么类中的默认构造函数就没有了。
3、多个构造函数是以重载的形式存在的。
示例:4.2 与一般函数区别:
1、一般函数和构造函数什么区别呢?
构造函数:对象创建时,就会调用与之对应的构造函数,对对象进行初始化。
一般函数:对象创建后,需要函数功能时才调用。
构造函数:对象创建时,会调用并且只调用一次。
一般函数:对象创建后,可以被调用多次。
一般函数:对象创建后,需要函数功能时才调用。
构造函数:对象创建时,会调用并且只调用一次。
一般函数:对象创建后,可以被调用多次。
2、创建对象都必须要通过构造函数初始化。
一个类中如果没有定义过构造函数,那么该类中会有一个默认的空参数构造函数。
如果在类中定义了指定的构造函数,那么类中的默认构造函数就没有了。
3、多个构造函数是以重载的形式存在的。
/** * 需求:演示构造函数重载 * @author jinlong * */package com.blog.part2.对象;class Person { private String name; private int age; //无参数构造函数 Person() { name="zhangsan"; age=1; System.out.println("Person1 run"); } //有参数构造函数,孩子一出生就命名。 Person(String n) { name=n; System.out.println("Person2 run"); } //孩子一出生就有名字和年龄 Person(String n,int a) { name=n; age=a; System.out.println("Person3 run"); } //定义speak方法来打印本对象的姓名年龄 public void speak() { System.out.println(name+":::"+age); } //这里省略get set方法}public class PersonDemo1 {public static void main(String[] args) {//创建一个孩子Person p1=new Person();p1.speak();//创建一个叫张三的孩子Person p2=new Person("张三");p2.speak();//创建一个叫李四的,三岁的孩子Person p3= new Person("李四",3); p3.speak();}}
运行结果:
从上边结果可知,构造函数也可以重载,满足不同的对象创建过程。
4.3构造代码块:
可以给所有对象进行初始化,并且构造代码块优先于构造函数执行。
/** * 需求:演示构造代码块 * @author jinlong * */package com.blog.part2.对象;class Person { private String name; private int age; //构造代码块,可以给所有对象进行初始化 { System.out.println("构造代码块运行了"); } //无参数构造函数 Person() { name="zhangsan"; age=1; } //有参数构造函数,孩子一出生就命名。 Person(String n) { name=n; } //孩子一出生就有名字和年龄 Person(String n,int a) { name=n; age=a; } //定义speak方法来打印本对象的姓名年龄 public void speak() { System.out.println(name+":::"+age); } //这里省略get set方法}public class PersonDemo1 {public static void main(String[] args) {//创建一个孩子Person p1=new Person();p1.speak();//创建一个叫张三的孩子Person p2=new Person("张三");p2.speak();//创建一个叫李四的,三岁的孩子Person p3= new Person("李四",3); p3.speak();}}
运行结果:
5. this关键字
this代表其所在函数所属对象的引用。换言之,this代本类对象的引用。
当成员变量和局部变量重名,可以用关键字this来区分,this就是所在函数所属对象的引用。
简单说,哪个对象调用了this所在的函数,this就代表哪个对象。一般方法调用默认加this。
什么时候使用this关键字呢?
当成员变量和局部变量重名,可以用关键字this来区分,this就是所在函数所属对象的引用。
简单说,哪个对象调用了this所在的函数,this就代表哪个对象。一般方法调用默认加this。
什么时候使用this关键字呢?
当在函数内需要用到调用该函数的对象时,就用this。
通常this被用来区分成员变量和局部变量
this还可以用来在构造函数中调用其他构造函数,这时候this在构造函数中被放在第一行。等继承那里还会学 到一个类似的关键字super,也要放在第一行。
示例:
/** * 需求:this关键字的应用 * @author jinlong * */package com.blog.part2.对象;class Person{ private String name ; private int age ; Person(String name) { //通过this区分成员变量和局部变量 this.name = name; } Person(String name, int age) { //this也可以用于在构造函数中调用其他构造函数 this(name); this.age = age; } public void speak() { System.out.println(name + ":" + age); }}class ConsDemo{ public static void main(String[] args) { Person p1 = new Person("张三" ); p1.speak(); Person p2 = new Person("李四" ,1); p2.speak();}}
6. static关键字
6.1 定义及特点
static关键字:用于修饰成员(成员变量和成员函数)。
被修饰后的成员具备以下特点:
1、随着类的加载而加载。
2、优先于对象存在。
3、被所有对象所共享。
4、可以直接被类名调用。
被修饰后的成员具备以下特点:
1、随着类的加载而加载。
2、优先于对象存在。
3、被所有对象所共享。
4、可以直接被类名调用。
6.2 成员变量和静态变量的区别
6.2.1 区别
1. 两个变量的生命周期不同
成员变量随着对象的创建而存在,随着对象被回收而释放。
静态变量随着类的加载而存在,随着类的消失而消失。
2. 调用方式不同
成员变量只能被对象调用。
静态变量可以被对象调用,还可以被类名调用。
3. 别名不同
成员变量也称为实例变量。
静态变量也称为类变量。
4. 数据存储位置不同
成员变量存储在堆内存的对象中,所以也叫对象的特有数据。
静态变量数据存储在方法区(共享数据区)的静态区,所以也叫对象的共享数据。
1. 静态方法只能访问静态成员,如果访问非静态成员,就会报错!成员变量随着对象的创建而存在,随着对象被回收而释放。
静态变量随着类的加载而存在,随着类的消失而消失。
2. 调用方式不同
成员变量只能被对象调用。
静态变量可以被对象调用,还可以被类名调用。
3. 别名不同
成员变量也称为实例变量。
静态变量也称为类变量。
4. 数据存储位置不同
成员变量存储在堆内存的对象中,所以也叫对象的特有数据。
静态变量数据存储在方法区(共享数据区)的静态区,所以也叫对象的共享数据。
6.2.2 使用注意:
原因:静态方法和变量存在的时候,对象还不存在,非静态变量也不存在,肯定无法访问。
2、静态方法中不可以写this,super关键字。
原因:静态方法存在的时候,对象还不存在,this代表的就是调用方法的那个对象,既然不存在,肯定不可以写在静态方法中。
3、主函数是静态的,主函数特殊之处:
1. 格式是固定的。
2. 被jvm所识别和调用。
原因:静态方法存在的时候,对象还不存在,this代表的就是调用方法的那个对象,既然不存在,肯定不可以写在静态方法中。
3、主函数是静态的,主函数特殊之处:
1. 格式是固定的。
2. 被jvm所识别和调用。
主函数各成分解析:
public:权限必须是最大的,被jvm调用。
static:不需要对象调用,直接用主函数所属类名调用即可。 命令行窗口中输入:java StaticDemo,实际上就是在执行 StaticDemo.main();。
void: 主函数不需要具体的返回值。
main: 函数名,不是关键字,只是一个jvm识别的固定的名字。
String[] args:这是主函数的参数列表,是一个数组类型的参数,而且元素都是字符串类型。
public:权限必须是最大的,被jvm调用。
static:不需要对象调用,直接用主函数所属类名调用即可。 命令行窗口中输入:java StaticDemo,实际上就是在执行 StaticDemo.main();。
void: 主函数不需要具体的返回值。
main: 函数名,不是关键字,只是一个jvm识别的固定的名字。
String[] args:这是主函数的参数列表,是一个数组类型的参数,而且元素都是字符串类型。
6.3什么时候使用静态
6.3.1 静态变量
当分析对象中所具备的成员变量的值都是相同时,这时这个成员就可以被静态修饰。只要数据在对象中都是不同的,就是对象的特有数据,必须存储在对象中,是非静态的。
如果是相同的数据,对象不需要做修改,只需要使用即可,不需要存储在对象中,定义成静态的。
/** * 需求:静态的使用 * @author jinlong * */package com.blog.part2.对象;class Person{ //成员变量,实例变量 String name; //静态变量,类变量 //所有对象共享的属性用static修饰 static String country = "CN"; public void show() { System.out.println(country + ":" + name); //等效语句:System.out.println(Person.country + ":" + this.name); }}class StaticDemo{ public static void main(String[] args) { Person p = new Person(); System.out.println(p.country); //可以用类名直接调用 System.out.println(Person.country); //不管建立多少个对象,country的值都是相同的。 }}
6.3.2 静态函数
函数是否用静态修饰,就参考一点,就是该函数功能是否需要访问到对象中的特有数据。简单点说,从源代码看,该功能是否需要访问非静态的成员变量,如果需要,该功能就是非静态的。
如果不需要,就可以将该功能定义成静态的。当然,也可以定义成非静态,但是非静态需要被对象调用。
如果没有访问特有数据的方法,该对象的创建是没有意义。
6.3.3 静态代码块
随着类的加载而执行,而且只执行一次。作用:用于给类进行初始化。
6.3.4 工具类
当某个功能类中使用的数据都是用户输入的数据,这是可以考虑让程序更加严谨不建立对象,可以将这个类的方法都定义成静 态的static,直接通过类名调用即可。为了进一步避免该类被建立成对象,可以将构造函数私有化。
6.3.4 工具类
当某个功能类中使用的数据都是用户输入的数据,这是可以考虑让程序更加严谨不建立对象,可以将这个类的方法都定义成静 态的static,直接通过类名调用即可。为了进一步避免该类被建立成对象,可以将构造函数私有化。
示例:
/** *需求:定义一个工具类,并使用 * @author jinlong * */package com.blog.part2.对象;//定义数组工具类class ArrayTools{//私有话构造函数,禁止创建这个工具类的对象。private ArrayTools(){};//将我们前边用过的方法定义静态方法//对数组进行选择排序 public static void selectSort(int[] arr) { for(int x = 0; x <arr.length -1; x++) { for(int y = x + 1; y < arr.length; y++) { if(arr[x] > arr[y]) swap(arr,x,y); } } } //用于给数组进行元素的位置置换。 private static void swap(int[] arr, int a,int b) { int temp = arr[a]; arr[a] = arr[b]; arr[b] = temp; } //遍历打印数组方法 public static void printArray(int[] arr) { System.out.print("[" ); for(int x = 0; x < arr.length; x++) { if(x != arr.length - 1) System.out.print(arr[x] + "," ); else System.out.println(arr[x] + "]" ); } }}public class ArrayToolsDemo { public static void main(String[] args) { //定义数组int [] arr= {2,5,1,8,6,4,3};//无需创建工具类对象,直接调用工具类方法ArrayTools.printArray(arr);ArrayTools.selectSort(arr);ArrayTools.printArray(arr); }}运行结果:
7. 单例设计模式
7.1 概述
设计模式:对问题行之有效的解决方式,其实,它是一种思想。
单例设计模式解决的问题:就是可以保证一个类在内存中的对象唯一性。
比如多个程序使用同一个配置信息对象时,就需要保证该对象的唯一性。
单例设计模式解决的问题:就是可以保证一个类在内存中的对象唯一性。
比如多个程序使用同一个配置信息对象时,就需要保证该对象的唯一性。
如何保证对象唯一性呢?
1、不允许其他程序用new创建该类对象。
2、在该类创建一个本类实例。
3、对外提供一个方法让其他程序可以获取该对象。
步骤:
1、私有化该类构造函数。
2、通过new在本类中创建一个本类对象。
3、定义一个公有的方法,将创建的对象返回。
7.2 分类
饿汉式:
/** * 需求:设计单例设计模式类:饿汉式 * 思路: 之所以不用Single.s;的方式获取Single对象,而采用getInstance获取是因为在getInstance方法中 * 我们可以做一些判断来决定是否返回Single的对象,也就是实现了对单例对象的可控。所以,给 * Single的构造方法加上了private限制,禁止使用者直接采用Single.s;的方式获取。 * @author jinlong * */package com.blog.part2.对象;//单例类class Single{//类已加载,对象就已经存在了 private static Single s = new Single(); private Single(){} //这里提供静态方法,返回Single对象。 //还可以在这里加入判断语句来控制是否返回Single对象。 public static Single getInstance() { return s ; }}class SingleDemo{ public static void main(String[] args){ Single s1 = Single. getInstance(); Single s2 = Single. getInstance(); System.out.println(s1 == s2); }}
运行结果为true,s1和s2引用的是同一个对象。
懒汉式:
/** * 需求:设计单例设计模式类:懒汉式 * 思路: 懒汉式又叫做延迟加载,原理就是类加载时,还没有建立对象, * 存在延迟,只有当调用静态方法时才会创建该类的对象。 * @author jinlong * */package com.blog.part2.对象;//单例类class Single{//类加载进来,没有对象,只有调用了getInstance方法时,才会创建对象 //延迟加载形式 private static Single s = null; private Single(){} //这里提供静态方法,返回Single对象。 //还可以在这里加入判断语句来控制是否返回Single对象。 public static Single getInstance() { return s ; }}class SingleDemo{ public static void main(String[] args){ Single s1 = Single. getInstance(); Single s2 = Single. getInstance(); System.out.println(s1 == s2); }}
0 0
- 黑马程序员 java基础<—>--->面向对象
- 黑马程序员——Java基础---java面向对象基础
- 黑马程序员——java基础--面向对象基础
- 黑马程序员——java基础——面向对象
- 黑马程序员——java基础——面向对象
- 黑马程序员——java基础——面向对象
- 黑马程序员——Java基础——面向对象
- 黑马程序员——java基础—-面向对象
- 黑马程序员——java基础—面向对象
- 黑马程序员——Java基础---面向对象
- 黑马程序员——java基础学习(面向对象)
- 黑马程序员——java基础_面向对象
- 黑马程序员-Java基础总结04——面向对象
- 【黑马程序员】Java基础学习博客——面向对象
- 黑马程序员——java基础面向对象基础知识总结
- 黑马程序员——JAVA基础之面向对象
- 黑马程序员——Java基础---面向对象
- 黑马程序员——java基础---面向对象(一)
- 分析java内存问题
- 【HDOJ 1005】 CRB and His Birthday
- Invalid command 'WSGIScriptAlias', perhaps misspelled or defined by a module not included in the ser
- Python循环语句
- hdu1069//zoj1093 Monkey and Banana (排序,dp)
- 黑马程序员——Java基础---面向对象
- 2012 Multi-University Training Contest 5 Problem G The Beautiful Road(HDU4346)
- 黑马程序员-JAVA基础之面向对象
- highchars
- 中国DVR卡发展过程与趋势分析
- 机器学习中的相似性度量
- Android中的IPC通信(一)
- 在spring中使用quartz进行任务调度遇到的问题
- 2038问题