java面向对象

 

 

1.面向对象是相对于面向过程而言的。

　　（1）面向过程强调过程，执行者。

　　（2）面向过程强调过程，指挥者。我让你帮我买烟，就是面向对象。我自己去买烟就是面向过程。

　　（3）面向对象的特点：a.封装b.继承c.多态

2.类和对象:

　　（1）类是对现实世界的描述。

　　（2）对象是现实中存在的个体。

 

3.成员变量和局部变量

　　（1）作用范围：局部变量在方法内，成员变量在类中。

　　（2）存储空间：局部变量在栈中，成员变量在堆中。

　　（3）初始化值：局部变量人工初始化赋值，成员变量jvm默认初始化。

 

4.匿名对象的使用

　　（1）对对象中的功能只执行一次的时候使用，否则用有名字对象。

　　（2）勇于作为实际参数进行传递。

 

5.封装：把属性隐藏仅对外提供公共的访问方法。

　　好处：便于重复使用，安全性高。

6.private：

　　（1）可以早方法中对成员变量的访问进行控制。私有只是封装的一种体现形式。

　　（2）常用方法：

　　　无返回值　void setAge(int a){}

　　　又返回值　int getAge(){}

class Demo{
　　int age;//把属性私有对外提供公共的访问方法,可控性提高了
　　public void setAge(int age){//age = -20;
　　　　if(age>=0 && age<=200){
　　　　this.age = age;
}
else {
　　System.out.println('请回火星');
　　}
}

public int getAge(){
　　return age;
　　}
}
class DemoTest{r /> public static void main(String[] args) {
　　Demo d = new Demo();
　　d.setAge(-20);
　　System.out.println(d.getAge());
　　}
}

 

7.构造函数特点：

　　（1）方法名必须与类名相同

　　（2）构造函数没有返回值也不能定义为void，方法名前不声明方法类型

　　（3）构造方法不能有编程人员调用而是由系统调用

　　（4）一个类可以定义多个构造方法

　　（5）若没定义构造函数系统会给一个默认的无参构造函数

　　（6）给对象初始化，一建立对象系统就会自行调用

 列：

class Person{
　　int age;
　　String name;
　　Person(){}//无参的构造器
Person(int age,String name) {//age = 20,name = 'zhangsan';
　　this.age = age;
　　this.name = name;
　　}
public void speak(){
System.out.println(age + '.....' + name);
　　}
}

 

*****************************************
class Demo{
public static void main(String[] args) {
　　//Person p = new Person(20,'zhangsan');
　　Person p = new Person();
　　p.speak();
　　}
}

8.this关键字：哪个对象调用this所在的函数this就代表了那个对象。

　　作用：

　　　　（1）函数参数或者函数中的局部变量和成员变量同名的情况，用this.成员变量名来引用成员变量。

　　　　（2）在函数中需要引用该函数所属类的当前对象时候直接用this

　　　　（3）this（参数列表）在一个构造函数中调用另一个构造函数用这种this语句（只可放在构造函数第一行）。

列：
Person(String name){
　　this.name = name;
}
Person(String name,int age){
　　this('张三');//是找带一个字符串类型参数的构造方法
　　this.name = name;
　　this.age = age;
　　//this('zhangsan');
}

****************************************************

class Demo{
public static void main(String[] args) {
　　　Person p = new Person('lisi',20);

　　}
}

9.代码块：

（1）局部代码块定义在方法里，可以控制变量的生命周期

（2）构造代码块定义在类里，每创建一次对象就执行一次

（3）静态代码块给类进行初始化，只在第一次new执行一次。

　　Person p =new Person的过程中在内存做了什么：

a.将Person.class加载进内存

b.p定义函数中，在栈内存中开辟了变量空间p

c.在堆内存中分配空间并分配内存地址值，

d.给对象中的属性进行默认初始化额

e.给对象中的值进行显示初始化

f.调用构造代码块对对象进行初始化

g.调用构造函数进行初始化

h.将对象的内存地址值赋值给p变量，让p变量指向该对象。

10.static静态用于修饰成员变量，成员被静态修饰后可以直接用：类名.静态成员调用。

静态特点：

随类的加载而加载，生命周期长。优先于对象存在。被所有对象共享。静态变量都被存储在方法区。实例变量是非静态成员变量，类变量是静态变量。类变量随类的加载存在于方法区，实例变量随对象的建立存在于堆中。类变量所属于整个类，被所有对象共享，实例变量是对象的特有数据。

要注意：1）静态方法只可以访问静态成员，非静态方法既可以访问静态页可以访问非静态。

2）静态方法中不可以定义this super关键字因为静态优先于对象存在，所以静态方法中不可以出现this。

 

静态的利弊：对对象的共享数据提供单独的存储空间，不用每个对象都存一份节约内存，可以类名.直接调用。生命周期过长，静态虽好，只可访问静态。

什么时候可以使用静态：成员变量所存储的数据每个变量否拥有这个数据，没必要存储到对象中，让所有对象共享该数据即可，用static修饰。

什么时候定义静态函数：当成员函数没有访问对象的特有数据是，就将该方法定义成静态的，该方法没有访问到静态的特有数据，直接类名.调用即可。

 

11.单利设计模式：

饿汉式：

　　1）私有构造函数

　　2）创建一个本类对象

　　3）定义一个公共的访问方式：

class Single {
　　private Single() {}
　　private static Single s = new Single ();
　　public static Single getInstance(int num) {
　　　　return s;
}
懒汉式：

1）私有构造函数

2）声明一个本类引用

3 )定义一个公共的访问方式
class Single {
　　private Single() {}
　　private static Single s;
public static Single getInstamce (int num) {
　　if (s==null) {
　　s = new Single();
　　}
return s;
}