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());
}
}
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);
}
}
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();
}
}
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');
}
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);
}
}
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;
}
懒汉式：
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;
}
class Single {
private Single() {}
private static Single s;
public static Single getInstamce (int num) {
if (s==null) {
s = new Single();
}
return s;
}