1. 面向对象和面向过程

(1)面向过程 强调过程，执行者：它是一种更符合人们思考习惯的思想；

(2)面向对象 强调对象，指挥者：它使复杂的内容简单化；

(3)面向对象思想的特点：它使我们从执行者变成了指挥；

2. 面向对象的特点

封装；继承；多态

3. 类和对象

(1)类对现实世界中同一类事物的描述(成员变量和方法)；

(2)对象现实世界中实际存在具体的个体；

4. 成员变量与局部变量的区别

1.作用域：

成员变量的作用域是整个类中都可以访问；

局部变量是的作用域是定义它的{}内, {}中的语句执行完它就被回收；

2.初始值：

局部变量使用前必须手动赋值, 系统不会赋默认值；成员变量系统会赋默认初始值.

3.所在内存区域：

局部变量在方法运行的栈内存里,在栈里,会自动释放；包括调用对象中的方法的入参，在方法调用时会在栈内存中创建空间当方法调用完毕之后，就会被释放掉。

成员变量在对象里,对象在堆里,成员变量也在堆里,不使用的对象会被垃圾回收机制在不确定的时候回收.

但是你如果指定了构造方法的话编译器就不会在给你指定了，也就是说不可以new Point()要写你指定的那一个

package cn.czbk.no4;

public class Car {
String dest;
int num;
public void run(){
int x=10;
System.out.println(num+"....."+dest);
System.out.println(x);
}
public void show(){
System.out.println(num+dest);
}
public static void main(String[] args) {
Car car =new Car();
car.run();
car.show();
}
}

6. 封装

(1)封装的好处：便于重复使用，安全性高。

(2)private（私有的）权限修饰符。

7. private(私有)

private 修饰成员变量和成员不能在其他类中直接访问.

注意：私有仅仅是封装的一种体现形式, 封装是一种思想, 就是将具体实现隐藏, 仅对外 暴露访问方式.

8. 构造方法

(1)用途：用于给对象中属性进行初始化。

A：格式 类名(){code}Person(){}

B：Person(){}public Person(){}

(2)特点 不定义空参构造，系统会自动给一个空参构造，定义了构造方法无论是有参 还空参的，系统就不再给空参数的了 

(3)重载构造方法,是根据参数列表来区分是哪个构造方法。 

9. this 关键字

每个对象都有一个指向自己的指针，就 this。

10. this 的作用

1.在方法中区分成员变量和局部变量.this.成员变量；

2.this 语句可以在构造方法里调用其他构造方法；

3.在一个方法中,this 可以调用本类的其他方法,可以省略：

(1)代表当前对象的引用。使用的时候，谁调用方法，this 就代表谁。 (2)什么时候使用 this 呢？

A：当局部变量和成员变量重名的时候,可以用 this 进行区分。

B：this 调用成员方法

C：this 调用本类其他构造, 注意必须放在构造方法第一行。

package cn.czbk.no4;

public class TestThis {

    String name;
    String sex;
    public TestThis(){
        //this就是代表一个对象也就是相当于构造方法所以不能TestThis(‘小王‘,‘男‘)
        this("小王", "男");
    }
    public TestThis(String name,String sex){
        this.name=name;
        this.sex=sex;
    }
    public String getName(){
        return this.name;
    }
    public void setName(String name){
        this.name=name;
    }
    public String getSex(){
        return this.sex;
    }
    public void setSex(String sex){
        this.sex=sex;
    }
    public static void main(String[] args) {
        TestThis test=new TestThis();
        System.out.println(test.name+test.sex);
    }
}

11. 创建对象在内存中的详细步骤: Person p = new Person();

1.主方法进栈,给类类型变量 p 分配空间

2.在堆内存中开辟空间，分配内存地址

3.在堆内存中建立对象特有属性，并进行默认初始化

4.对属性进行显式初始化

5.将内存地址赋给栈内存中的 p 变量

12. static(静态)特点

随着类的加载而加载，随着类的消失而消失。优先于对象。静态可以被所有对象共享， 也可以被类名所调用。

package cn.czbk.no4;

public class TestStatic {
static int a;
static String s="在类加载时即可调用";
public static void show(){
System.out.println("不用创建对象即可以直接调用");
}
public static void main(String[] args) {
TestStatic test=new TestStatic();
test.show();
System.out.println(test.s+test.a);
}
}

package cn.czbk.no4;

public class StaticDemo {
public static void main(String[] args) {
Person p=new Person();
p.sayHi(Person.b);
}
}
class Person{
String a;
public static String b="123";
void sayHi(String s){
System.out.println(s);
}
}

13. 方法区

方法区是各个线程所共享的内存区域,它用于存储已被虚拟机加载的类信息,常量,静态变 量,即时编译器编译后的代码等数据.

局部代码块&构造代码块&静态代码块：

局部代码块：

作用：控制变量的生命周期 构造代码块：

作用：它可以给所有对象进行初始化,存在于类中。当类中的构造方法以重载的形式 存在时，并且有共同成员变量或共同的方法时，可以通过构造代码块对其进行初始化；这样 可以减少代码的重复。

静态代码块：

作用：加载驱动器。当类中的方法都被静态化，并且构造方法被 private 了，这时我 们不能，在将这个类实例化，然而又想让类增加一些属性，就可以使用静态代码块。

package cn.czbk.no4;

public class TestSequence {
public TestSequence(){
System.out.println("调用构造方法");
}
TestSequence(String s){
System.out.println("调用构造方法"+s);
}
static{
int a=9999;
System.out.println("静态代码区"+(a+1));
}
{
System.out.println("构造代码区");
}
public static void main(String[] args) {
TestSequence t=new TestSequence();
TestSequence s=new TestSequence("abc");
}
}

14. 静态的使用

类的成员用 static 修饰后,就多了一种调用方式,原来对象名.成员可以继续调用,现 在,通过类名.成员,也可以调用.

类在什么时候加载？

在第一次使用的时候加载,而后就常驻内存.

16. final 关键字

final 可以修饰类，方法，变量。final 修饰的类不可以被继承。final 修饰的方法不可以 被覆盖。final 修饰的变量是一个常量, 只能被赋值一次。

17. final 和 private 区别

final 修饰的类可以访问。
private 不可以修饰外部类,但可以修饰内部类,讲内部类的时候会演示
final 和 private 修饰的方法子类无法重写, final 不允许重写, private 重写不了.
final 修饰的变量只能在显示初始化或者构造方法初始化的时候赋值一次，以后不能更改。 private 修饰的变量，也不允许直接被子类或一个包中的其它类访问或修改，但是他可以

通过 set 和 get 方法对其改值和取值。

Java面向对象