我的java日记(面向对象上)

知识是学出来的,经验是积累出来的.经过这么几天的学习,让我对java又有了新的认识,有了更进一步的认识.希望我能进入黑马十三期学习.

一:(重点)

1:面向对象: 强调的是结果,对象

面向对象是相对于面向过程而言的,是基于面向过程的.

将功能封装进对象.

面向过程: 强调的是功能

强调的是完成某个功能的过程.

面向对象和面向过程都是一种编程思想,这种思想是来源于生活.

2:面向对象的特点:

A:是一种符合人们思考习惯的思想

B:可以将复杂的事情简单化

C:将程序员从执行者转换成了指挥者

3:完成需求：

A:先要去找具有所需的功能的对象来用。

B:如果该对象不存在，那么创建一个具有所需功能的对象。

C:这样简化开发并提高复用

4:面向对象的特征:

封装(encapsulation)

继承(inheritance)

多态(polymorphism)

5:面向对象的开发:其实就是在不断的创建对象,调用对象的功能完成事情.

二:类和对象

1: java中描述事物通过类的形式体现，类是具体事物的抽象，概念上的定义。

对象就是该类事物实实在在存在的个体。(在堆内存中)

使用计算机语言就是不断的在描述现实生活中的事物。

现实生活中,我们一般是通过外在特征及行为来描述每一个事物.

我们可以把对事物的描述通过java语言中的类来实现.

事物的特征-----类中的成员变量(属性)

事物的行为(功能)-----类中的成员方法(函数,功能)

2:一个java文件中可以有多个类,但是只有一个带main方法的类,并且要求文件名必须和带主方法的类的名一致.

3:对象的内存地址组成:对象的类型@地址值

4:如何通过对象使用成员方法和成员变量(重点)

格式:

对象名.成员变量名;

对象名.成员方法名();

5:内存关系:

对象名在栈中.

对象,成员变量在堆中

成员方法在方法区.

每new一个对象,就会在堆内存中开辟一块空间

6:成员变量和局部变量:(重点)

成员变量：

成员变量定义在类中，在整个类中都可以被访问。

成员变量随着对象的建立而建立，存在于对象所在的堆内存中,随着对象的消失而消失.

成员变量有默认初始化值。

局部变量：

局部变量只定义在局部范围内，如：函数内，语句内等。

局部变量存在于栈内存中。当方法调用完或语句结束后自动释放.

作用的范围结束，变量空间会自动释放。

局部变量没有默认初始化值,使用前必须要先赋值。

如果局部变量和成员变量的名相同,那么在方法体内用局部变量.

7:匿名对象:(次重点)

没有名字的对象,它是对象的简写形式.

匿名对象两种使用情况

(1)只一次调用类中的方法 new Person().show();效率较高

(2)可以作为实际参数在方法传递中使用

method(new Person());

例:

/*

匿名对象：没有名字的对象。

匿名对象是对象的简化形式

匿名对象的使用场景：

1：当对对象方法仅进行一次调用的时

2：匿名对象可以作为实际参数进行传递

*/

class Person

{

int number = 20;

public void show()

{

System.out.println("show--haha");

}

}

class NiMingDemo

{

public static void main(String[] args)

{

Person p = new Person();

p.show();

System.out.println(p.number);

//匿名对象的使用

new Person().show(); //创建了一个匿名对象

System.out.println(new Person().number); //又创建了一个匿名对象

System.out.println("************************");

/*

Person p1 = new Person();

method(p1);

Person p2 = new Person();

method(p2);

*/

method(new Person());

method(new Person());

}

public static void method(Person p) //p1赋值给了p

{

p.show();

}

}

三:封装(重点)

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

1: 好处：

将变化隔离。(例:cup升级)

便于使用。 (例:开机)

提高重用性。

提高安全性。

2: 封装原则：

将不需要对外提供的内容都隐藏起来。

把属性都隐藏，提供公共方法对其访问。

3: private关键字：

是一个权限修饰符。

用于修饰成员(成员变量和成员方法)

被私有化的成员只在本类中有效,不能直接被其他类直接访问

把类中的成员变量私有化(其实就是用private修饰),对外提供public的方法使用.

常用之一：

(由于方法名是很重要的,所以,我们所起的方法名,一定要有意义,一般来说,通过方法名,就可以看出该方法是什么作用.

习惯上:我们把成员变量私有化后,提供了set***,get***方法命名)

将成员变量私有化，对外提供对应的公共的set ，get方法对其进行访问。提高对数据访问的安全性。

4:私有化只是封装的一种体现

例:

class Person

{

String name;

//用private修饰age后，只能在本类中访问。

private int age;

/*

public void haha(int a)

{

if(a<0)

{

System.out.println("年龄有误");

}

else

{

age = a;

}

}

*/

public void setAge(int a)

{

if(a<0)

{

System.out.println("年龄有误");

}

else

{

age = a;

}

}

public int getAge()

{

return age;

}

public void show()

{

System.out.println(name+"***"+age);

}

}

class PersonDemo2

{

public static void main(String[] args)

{

Person p = new Person();

p.name = "凤姐";

//p.age = 28;

//p.age = -28;

//p.haha(-28);

//p.setAge(-28);

p.setAge(20);

p.show();

System.out.println("通过get方法获取值:"+p.getAge());

}

}

四:构造方法:

1:特点：

方法名与类名相同

不用定义返回值类型

没有具体的返回值。

2:作用：

创建对象,给对象进行初始化。

3:注意：

如果你没有给定构造方法,系统会自动给出一个默认的无参构造方法

多个构造函数是以重载的形式存在的。

如果你手动给出了构造方法,那么,系统将不再给出默认的无参构造.

4:建议:对自定义类,手动给出无参构造.public Person(){}

5:给成员变量进行赋值:

(1)使用set方法进行赋值(使用此方法较多)

(2)使用无参构造进行赋值

6:构造方法和普通成员方法的区别:

1:格式区别:

构造方法和类名相同,并且没有返回类型,也没有返回值

普通成员方法可以任意起名,必须有返回类型.可以没有返回值.

2:作用区别:

构造方法用于创建对象,并进行初始化值.

普通成员方法是用于完成某个功能的.

3:调用区别:

构造方法是在创建对象时,用new调用的.

普通成员方法是由创建的对象调用的.

构造方法先于普通成员方法执行.

例:

class Person

{

String name;

int age;

Person()

{

//name = "章子怡";

//age = 20;

System.out.println("Person()");

}

Person(String n)

{

name = n;

}

Person(int a)

{

age = a;

}

Person(String n,int a)

{

name = n;

age = a;

}

public void show()

{

System.out.println(name+"***"+age);

}

}

class ConDemo

{

public static void main(String[] args)

{

//Person p = new Person();

//p.show();

Person p2 = new Person("柳岩");

p2.show();

}

}

五:this关键字

特点：this代表其所在方法所属对象的引用。谁调用某个方法,那么,在这个方法内部,this就代表谁.

换言之：this代本类对象的引用。

什么时候使用this关键字呢？

(1)当在方法内需要用到调用该方法的对象时，就用this。

(2)局部变量隐藏全局变量 this.成员变量名;

(3)在构造方法中调用其他构造方法 this(变量名); 必须是构造函数中的第一个语句.

例:

/*

this关键字:this代表其所在方法所属对象的引用

谁调用方法，this就代表谁。

使用场景：

1：局部变量隐藏成员变量。

2：在构造方法中，调用其他的构造方法。this(参数)

注意：this调用构造必须放在第一条语句。

*/

class Person

{

private String name;

private int age;

Person(){}

Person(String name)

{

this.name = name;

}

Person(String name,int age)

{

//this.name = name;

this(name);

this.age = age;

}

public void setName(String name) //林志玲

{

//局部变量隐藏成员变量

this.name = name;

}

public String getName()

{

return name;//这里其实是省略this

}

public void show()

{

System.out.println(name+"***"+age);

}

}

class ThisDemo

{

public static void main(String[] args)

{

Person p = new Person();

//给成员变量赋值

p.setName("林志玲");

p.show();

System.out.println("名字是:"+p.getName());

Person p2 = new Person("周慧敏",48);

p2.show();

}

}

练习

//求矩形的面积

class RectangleDemo

{

public static void main(String[] args)

{

Rectang rec=new Rectang();

rec.setChang(20);

rec.setWide(15);

System.out.println("长为:"+rec.getChang()+"m,宽为:"+rec.getWide()+"m");

System.out.println("矩形面积为:"+rec.area()+"㎡");

}

}

class Rectang //矩形类

{

private int chang; //长

private int wide; //宽

public Rectang(){}; //无参构造

public void setChang(int chang){

this.chang=chang;

}

public void setWide(int wide){

this.wide=wide;

}

public int getChang(){

return chang;

}

public int getWide(){

return wide;

}

public int area(){

return chang*wide;

}

}

六:代码块:就是用一对{}括起来的内容.

1: 局部代码块:在方法体中,用一对{}括起来的语句.当{}的语句结束,在语句块中的变量就会在内存中消失,可以提高内存的使用率.

构造代码块: 存放在代码区

在类的成员位置上(即在方法外),用于进行初始化,先于成员方法和构造方法执行.每个构造方法都会去默认调用构造代码块.

静态代码块:static{},是最先执行的代码块(比main方法还要先执行),但不管创建多少对象只执行一次.

作用:当类在加载进内存的时候,如果需要进行一些初始化,就可以考虑使用静态代码块.

执行顺序:静态代码块,构造代码块,构造方法,成员方法.

2:代码在内存中的执行顺序

Person p=new Person();在内存中做了哪些事情?

(1)将Person.class文件加载进内存空间中.

(2)如果p定义在主方法中,那么,就会在栈空间中开辟一个变量空间p

(3)在堆内存给对象分配空间.

(4)对对象中的成员进行默认初始化. String str;

(5)对对象中的成员进行显示初始化 . String str="abc";

(6)调用构造代码块对对象进行初始化.

(7)调用构造方法对对象进行初始化,对象初始化完毕

(8)将对象的内存地址赋给p变量,让p变量指向该变量.

例:比较两个人的年龄是否相等

/*

需求：比较两个人的年龄是否相等。

明确：

返回类型 boolean

未知内容 两个人的年龄

*/

class Person

{

private int age;

Person(){}

public void setAge(int age)

{

this.age = age;

}

public int getAge()

{

return age;

}

/*

public boolean compare(int age1,int age2)

{

if(age1==age2)

{

return true;

}

else

{

return false;

}

}

*/

//以上代码继续改进，因为我们比较的是两个人的年龄是否相等。

/*

public boolean compare(Person p1,Person p2)

{

if(p1.age == p2.age)

{

return true;

}

else

{

return false;

}

}

*/

//对象调用功能的时候，还传递对象本身比较别扭，所以程序需要改进。

public boolean compare(Person p) //把p2赋值给了p

{

//p1调用这个功能，所以，this代表p1,this代表调用它的对象

/*

if(this.age == p.age)

{

return true;

}

else

{

return false;

}

*/

//简化

//boolean flag = (this.age==p.age?true:false);

//return flag;

//再简化

//return (this.age==p.age?true:false);

//再简化

return (this.age==p.age);

}

}

class ThisTest

{

public static void main(String[] args)

{

Person p1 = new Person();

p1.setAge(20);

Person p2 = new Person();

p2.setAge(10);

//System.out.println(p1.compare(p1,p2));

//System.out.println(p2.compare(p1,p2));

System.out.println(p1.compare(p2));

}

}

七:static(静态)关键字(表示所有对象所共有的) ,在内存中存储在方法区中的静态区中(在方法区中有专门来存储静态成员的静态区)

可以用于修饰成员（成员变量和成员函数）

被修饰后的成员具备以下特点：

随着类的加载而加载,优先于对象存在,

被该类中所有对象所共享

可以直接被类名调用,当然通过对象名也可以调用.一般推荐使用类名调用.

使用static注意注意

(1)静态方法只能访问静态成员(静态方法不能调用非静态成员,非静态可以调用静态成员)

因为静态的内容对着类的加载而加载,它是优先于对象存在的.

(2)静态方法中不可以写this，super关键字

因为this和super代表的是对象,而静态加载进内存的时候,可能还没有对象.所以,静态方法中不能有this和super关键字.

先进内存的数据不可以访问后进内存的数据.

后进内存的数据可以访问先进内存的数据.

(3)主方法是静态的

public static void main(String[] args){}

public:公共的,是最大权限修饰符.

static:由于JVM调用main方法的时候,没有创建对象,只能通过类名调用,所以main方法必须使用static修饰.

void:由于main方法是由JVM调用,不需要返回值.用void修饰.

main:是主要的意思,所以jvm采用了这个名字,是程序的入口.

String[]:字符串数组.

args:数组名(是可变的).

在运行的时候,通过java命令给args数组赋值:

格式:java MainTest Hello word itcast

八:静态成员变量和非静态成员变量的区别:

1:调用方式:静态变量也成为类变量,可以直接通过类名调用,也可以通过类名调用.

成员变量也成为实例变量,只能通过对象名调用,这个变量属于对象.

2:存储位置:

静态变量存储在方法区中的静态区中.

成员变量存储在堆内存.

3:生命周期:

静态变量随着类的加载而存在,随着类的消失而消失,生命周期长.

成员变量随着对象的创建存在,随着对象的消失而消失.

4:与对象的相关性:

静态变量时所有的对象共享的数据.

成员变量是每个对象所特有的数据.

什么时候使用静态关键字?

A:当所有对象共享某个数据的时候,就把这个成员变成静态成员.

B:当某个方法没有访问该类的非静态成员,就可以把这个方法定义成静态修饰的.

静态的生命周期比较长,所以一般不推荐使用.

九:API:Application Program Interface 应用程序编程接口

@author:作者

@version版本

@param 参数

@return 表示返回值 例:@return int

私有的东西不必要写文档注释,即使写了在API文档中也显示不出来.

2:使用的是JDK\bin目录下的javadoc工具.

格式:javadoc -d 存放目录 -author -version 类名.java

十:单例设计模式

设计模式:把解决问题一系列经验进行总结,形成一个从具体到抽象的过程.有23中设计模式.

常用的设计模式:

单例设计模式,工厂设计模式,代理设计模式,

单例设计模式:用于保证类在内存中只有一个对象.

1:在本类中创建一个对象

2:为了控制对象的创建,所以,把构造方法私有化.

3:提供一个公共的访问方式.

构造私有化,使外部不能创建该类对象.

(1)用来保证类摘内存中只有一个对象.

(2)思路:

A:外界不能创建对象

B:本身要创建一个对象

C:提供共公的访问方式

如果体现思路呢?

A:私有构造 (使外界无法创建对象)

B:在成员位置创建一个对象

C:提供静态的公共方法获取对象

(3)单态设计的两种方式:饿汉式,懒汉式

饿汉式是开发使用,懒汉式是面试使用

例:

class Student

{

//构造私有是因为不想外界创建该类对象。

private Student(){}

//由于将来要提供对象，所以，我要创建对象。而这个对象，也不想再外界被人看到。所以，用private修饰。

//由于s在getInstance()被使用，所以，这里也要用static修饰

private static Student s = new Student();

//int x = 10;

//外界要直接访问此方式获取对象，所以，用static修饰

public static Student getInstance()

{

return s;

}

public void show()

{

System.out.println("明天休息");

}

}

class SingletonDemo

{

public static void main(String[] args)

{

/*

Student s1 = new Student(); //不能进行创建对象

Student s2 = new Student();

s1.show();

s2.show();

*/

//可以只用==进行判断

//System.out.println("s1==s2:"+(s1==s2));

Student s1 = Student.getInstance();

Student s2 = Student.getInstance();

System.out.println("s1==s2:"+(s1==s2));

s1.show();

s2.show();

}

}

例:

/*

懒汉式:

*/

class Student

{

private Student(){}

//由于使用的时候，才需要创建对象，所以，一开始默认给个null。

private static Student s = null;

public static Student getInstance()

{

//使用的时候创建对象

if(s==null)

{

s = new Student();

}

return s;

}

public void show()

{

System.out.println("今天下雨");

}

}

class SingletonDemo2

{

public static void main(String[] args)

{

Student s1 = Student.getInstance();

Student s2 = Student.getInstance();

System.out.println(s1==s2);

s1.show();

s2.show();

}

}