[Java知识库]身价过亿的御姐问我Java中的面向对象.......

前言

这篇只是面向对象的一部分，下一部分正在肝中

1 什么是面向对象

面向对象程序设计(oop)是当今主流的程序设计模式，它已经取代了20世纪70年代的“结构化”过程化程序设计开发技术。Java是完全面向对象的。

1.1 面向对象的优点

对于一些规模较小的问题，我们可以采取面向过程开发方式比较理想，如果我们要处理一些规模较大的问题，例如实现一个简单的web浏览器可能需要2000个过程，此时我们就可以采取另一中开发方式，采用面向对象的设计风格，我们可能只需要100个类，每个类平均包含20种方法，这种方式容易找到bug，如果给定对象的数据出错了，我们只要在访问过这个数据项的方法中查找就可以了。

1.2 类 对象

类是构造对象的模版，我们可以将类想象成制造房子的图纸，对象想象成房子，由类构造对象的过程叫做创建类的实例。

1. 类的概念
   只要是一门编程语言，就一定会有这个概念，类是将相同属性的东西放在一起，例如：在现实生活中我们可以将人看成一个类，这个类就是人类。
   我们可以将类看成一种自定义数据类型，可以使用类来定义变量，这种变量成为引用型变量，也就是说所有的类都是引用数据类型(这个概念在后面会讲到)。
   一般在写代码的时候先写类，然后在根据类创建对应的对象。

2. 对象
   对象是实际存在的，是从属于某个类的一个个实体，我们也称为实例，
   就是说：对象的抽象是类，类的具体化就是对象。

3. 属性
   属性是用来定义该类或该类对象所，在Java中属性是用来描述某一个对象的具体特征，例如，有个漂亮的小姐姐叫王冰冰，王冰冰这个名字就是一个属性，属性也叫成员变量。

4. 方法
   方法是用于定义该类或该类实例的行为特征或功能实现，它是一个动作行为或功能，每个对象都有自已的行为或功能，例如手机的功能有打电话，发短信，人可以说话，跑动。我们把这些行为称为方法。

5. 类中的成员
   属性和方法都是类的成员，它们是构成类的主要部分。

1.3 创建类

1.3.1 定义类

在java中使用关键字class定义类

public class 类名{
	//属性

	//方法
}

下面的代码定义一个名为Person的类，而Tom是这类的一个对象实例

//创建一个类
class Person{
    //属性
    String name;//名字
    String sex;//性别
    int age;//年龄
    //定义方法
    //这个方法的功能是实现自我介绍
    void show(){
        System.out.println("我叫:"+name+"\n性别:"+sex+"\n年龄:"+age);
    }
}
public class Demo01{
    public static void main(String[]args){
        //类方法与属性的使用
        Person Tom=new Person();//创建一个对象
        Tom.name="Tom";//对象的名字是Tom
        Tom.sex="男";//对象的性别是男
        Tom.age=18;//对象的年龄是18
        Tom.show();//使用自我介绍
    }
}

1.3.2 定义属性

public/protected/default/private/final/static 数据类型 属性名[=默认值];

(1)public/protected/default/private/final/static:修饰符。
(2)数据类型：属性的类型，可以是Java语言允许的任何数据类型。
(3)属性名：见名知意即可，与变量名字定义相同
(4)默认值：在定义属性时可以定义一个有用户指定的默认值，如果用户没有指定默认值，则该属性的默认值就是其属性的默认值。

1.3.3定义方法

public/protected/default/private/final/static/abstract 返回值类型 方法名(=list){

}

(1)public/protected/default/private/final/static :修饰符
(2)返回值类型：返回值类型可以是Java语言允许的任何数据类型，如果返回不为空(void),就要在最后一行写上return +返回值;

 public int add(){ //返回值为int
     int a=1;      
     int b=2;      
     return a+b;   
 }                 

(3)方法名：见名知意
(4)(=list):形参列表，形参列表用于定义该方法可以接收的参数，形参列表可以什么都不写，也可以由多组"类型+形参名"组合而成
例如：

public void show(String name,int age){
     System.out.println("我叫"+name+"今年"+age+"岁");
        }

1.3.4 成员变量与局部变量的区别

1. 区别1：代码中位置不同
   成员变量：类中方法外定义的变量
   局部变量：方法中定义的变量 代码块中定义的变量

class Person{
    //成员变量
    String name;
    int age;//年龄
    String sex;//性别
    double height;//身高
    //定义一个eat方法
    public void eat(){
        //局部变量
        String food="米饭";//食物
        //String food;重复命名会出错
        //这是一个代码块
        {
            //定义变量
            int a;//这个a也是一个局部变量
        }
    }
    public void show(){
        System.out.println(name);
        System.out.println(food);
    }

}
public class Demo01{
    public static void main(String[]args){
        Person a=new Person();
       a.show();
    }
}

2. 区别2：代码的作用范围
   成员变量：当前类的很多方法
   局部变量：当前一个方法（当前代码块）

class Person{
    //成员变量
    String name;
    int age;//年龄
    String sex;//性别
    double height;//身高
    public void eat(){
        //局部变量
        String food;//食物
        //String food;重复命名会出错
        //这是一个代码块
        {
            //定义变量
            int a;//这个a也是一个局部变量
        }
    }
}
public class Demo01{
    public static void main(String[]args){
        Person a=new Person();
        System.out.println(a.food);//访问局部变量

    }
}

3. 区别3：是否有默认值
   成员变量：有
   局部变量：没有
   
   引用数据类型： null

class Person{
    //成员变量
    String name;
    int age;//年龄
    String sex;//性别
    double height;//身高
    public void eat(){
        //局部变量
        String food;//食物
        //String food;重复命名会出错
        //这是一个代码块
        {
            //定义变量
            int a;//这个a也是一个局部变量
        }
    }
}
public class Demo01{
    public static void main(String[]args){
        Person a=new Person();
        System.out.println(a.name);//null
        System.out.println(a.age);//0
    }
}

4. 区别4：是否要初始化
   成员变量：不需要，不建议初始化，后续使用的时候再赋值即可
   局部变量：一定需要，不然直接使用的时候报错

class Person{
    //成员变量
    String name;
    int age;//年龄
    String sex;//性别
    double height;//身高
    public void eat(){
        //局部变量
        String food="米饭";//食物中必有的
        String food2;
        //String food;重复命名会出错
        //这是一个代码块
        {
            //定义变量
            int a;//这个a也是一个局部变量
        }
        System.out.println(food2);
    }
    public void show(){
        System.out.println(name);

    }

}
public class Demo01{
    public static void main(String[]args){
        Person a=new Person();
        //访问局部变量

    }
}

5. 区别5：内存中位置不同
   成员变量：堆内存
   局部变量：栈内存
6. 区别6：作用时间不同
   成员变量：当前对象从创建到销毁
   局部变量：当前方法从开始执行到执行完毕

1.4 面向对象执行的过程

1. 第一步遇到Person的时候，进行类的加载
2. 创建对象，为这个对象在堆中开辟空间(看不见)
3. 为对象进行属性的初始化(看不见)

1.4.1 构造器

构造器是一个创建对象时的自动调用的方法,用于对象属性的初始化，
构造器的作用不是为了创建对象，因为在调用构造器之前，这个对象就已经创建好了，并且属性有默认的初始化的值，调用构造器的目的是给属性进行赋值操作的。

new关键字实际上是在调用一个方法，这个方法叫构造方法（构造器）
调用构造器的时候，如果你的类中没有写构造器，那么系统会默认给你分配一个构造器，只是我们看不到罢了。可以自己显式 的将构造器编写出来：
构造器的格式：
[修饰符] 构造器的名字(){
}

public class Demo01{
    public static void main(String[]args){
        Person Tom=new Person();
         Tom.name="Tom";
         Tom.sex="男";
         Tom.age=18;
    }
}
class Person{
    //定义属性
    String name;
    String sex;
    int age;
    //定义构造器
    //定义一个空构造器
    public  Person(){

    }
    
    }
}

1.4.2构造器的重载

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

最常用的地方就是构造器的重载。

• 1.一般保证空构造器的存在，空构造器中一般不会进行属性的赋值操作，因为那样的话每个对象的属性就一样了， 实际上，我们只要保证空构造器的存在就可以了，里面的东西不用写

• 2.一般我们会重载构造器，在重载的构造器中进行属性赋值操作

• 3.在重载构造器以后，假如空构造器忘写了，系统也不会给你分配默认的空构造器了，那么你要调用的话就会出错了。

public class Demo01{
    public static void main(String[]args){
     Person Tom=new Person("Tom","男",18);
     /*Tom.name="Tom";
     Tom.sex="男";
     Tom.age=18;
     这样写太麻烦
     */
    }
}
class Person{
    //定义属性
    String name;
    String sex;
    int age;
    //定义构造器
    //定义一个空构造器
    
    public  Person(){

    }
    //定义一个实参构造器 
    public Person(String name,String sex,int age){
        //当形参名字和属性名字重名的时候，会出现就近原则：
        //在要表示对象的属性前加上this.来修饰 ，因为this代表的就是你创建的那个对象
        this.name=name;
        this.sex=sex;
        this.age=age;
    }
}

构造器和方法的区别：

• 构造器没有方法的返回值类型

• 方法体内部不能有return语句

• 构造器的名字很特殊，必须跟类名一样

1.5 this的使用

1. this修饰属性
   当属性名字和形参发生重名的时候或者属性名字和局部变量重名的时候，都会发生就近原则，所以如果我要是直接使用变量名字的话就指的是离的近的那个形参或者局部变量，这时候如果我想要表示属性的话，在前面要加上：this.修饰

public class Person {
    //属性
    int age;
    String name;
    double height;
    //空构造器
    public Person(){
    }
    //有参构造器
    public Person(int age,String name,double height){
        this.age = age;
        this.name = name;
        this.height = height;
    }
    //方法：
    public void eat(){
        int age = 10;
        System.out.println(age);//就近原则，age指的是离它近的age
        //局部变量的age
        System.out.println(this.age);//这里指代的就是属性的age
        System.out.println("我喜欢吃饭");
    }
}

2.this修饰方法
在同一个类中，方法可以互相调用，this.可以省略不写。

public class Person {
    //属性
    int age;
    String name;
    double height;
    //空构造器
    public Person(){
    }
    //有参构造器
    public Person(int age,String name,double height){
        this.age = age;
        this.name = name;
        this.height = height;
    }
    //方法：
    public void play(){
        /*this.*/eat();
        System.out.println("上网");
        System.out.println("洗澡");
    }
    public void eat(){
        System.out.println(/*this.*/age);
        System.out.println("吃饭");
    }
}

3. this修饰构造器
   同一个类中的构造器可以相互用this调用，注意：this修饰构造器必须放在第一行

public class Person {
    //属性
    int age;
    String name;
    double height;
    //空构造器
    public Person(){
    }
    //有参构造器
    public Person(int age,String name,double height){
        this(age,name);
        this.height = height;
    }
    public Person(int age,String name){
        this(age);
        this.name = name;
    }
    public Person(int age){
        this.age = age;
    }
   //定义方法
    public void play(){
        /*this.*/eat();
        System.out.println("上网");
        System.out.println("打篮球");
    }
    public void eat(){
        System.out.println(/*this.*/age);
        System.out.println("吃饭");
    }
}

1.6 static

有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字static（静态的）就能创建这样的成员。
如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为static。static 成员的最常见的例子是main（）。因为在程序开始执行时必须调用main() ，所以它被声明为static。
声明为static的变量称为静态变量或类变量。可以直接通过类名引用静态变量，也可以通过实例名来引用静态变量，但最好采用前者，因为后者容易混淆静态变量和一般变量。静态变量是跟类相关联的，类的所有实例共同拥有一个静态变量。
声明为static的方法称为静态方法或类方法。静态方法可以直接调用静态方法，访问静态变量，但是不能直接访问实例变量和实例方法。静态方法中不能使用this关键字，因为静态方法不属于任何一个实例。

1. static修饰属性

public class Test{
    public static void main(String[]args){
        Person a=new Person();//创建a对象
        a.name="王图灵";
        a.age=18;
        System.out.println(a.name);
        System.out.println(a.age);
        Person b=new Person();//创建b对象
        System.out.println("---------");
        System.out.println(b.name);//没有赋值  输出的为默认值null
        System.out.println(b.age);//并没有赋值 发现age的输出是1
        System.out.println(Person.age);//第二种访问格式
    }
}
class Person{
    //定义变量
    String name;//定义名字属性
     static int age;//定义年龄属性

}

2. static修饰属性总结：
   （1）在类加载的时候一起加载入方法区中的静态域中
   （2）先于对象存在
   （3）访问方式： 对象名.属性名 类名.属性名（推荐）
   static修饰属性的应用场景：某些特定的数据想要在内存中共享，这个情况下，就可以用static修饰的属性。

public class Demo {
    int id;
    static int sid;
    public void a(){
        System.out.println(id);
        System.out.println(sid);
        System.out.println("------a");
    }
    //1.static和public都是修饰符，并列的没有先后顺序，先写谁后写谁都行
    static public void b(){
        //System.out.println(this.id);//4.在静态方法中不能使用this关键字
        //a();//3.在静态方法中不能访问非静态的方法
        //System.out.println(id);//2.在静态方法中不能访问非静态的属性
        System.out.println(sid);
        System.out.println("------b");
    }
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //5.非静态的方法可以用对象名.方法名去调用
        Demo d = new Demo();
        d.a();
        //6.静态的方法可以用   对象名.方法名去调用  也可以 用  类名.方法名 （推荐）
        Demo.b();
        d.b();
       
    }
}

二次总结：

1. static和public都是修饰符，并列的没有先后顺序，先写谁后写谁都行
2. 在静态方法中不能访问非静态的属性
3. 在静态方法中不能访问非静态的方法
4. 在静态方法中不能使用this关键字
5. 非静态的方法可以用对象名.方法名去调用
6. 静态的方法可以用 对象名.方法名去调用 也可以 用 类名.方法名 （推荐

1.7 代码块

所谓代码块就是用大括号({})将多行代码封装在一起，形成一个独立的数据体，用于实现特定的算法。一般来说代码块是不能单独运行的，它必须要有运行主体。

在学习代码块的时候，我们要先弄清类由哪些东西组成的：类的组成：属性，方法，构造器，代码块，内部类
代码块分类：普通块，构造块，静态块，同步块（多线程）

public class Test {
    //属性
    int a;
    static int sa;
    //方法
    public void a(){
        System.out.println("-----a");
        {
            //普通块限制了局部变量的作用范围
            System.out.println("这是普通块");
            System.out.println("----000000");
            int num = 10;
            System.out.println(num);
        }
      
    }
    public static void b(){
        System.out.println("------b方法");
    }
    //构造块
    {
        System.out.println("------这是构造块");
    }
    //静态块
    static{
        System.out.println("-----这是静态块");
        //在静态块中只能方法：静态属性，静态方法
        System.out.println(sa);
        b();
    }
    //构造器
    public Test(){
        System.out.println("这是空构造器");
    }
    public Test(int a){
        this.a = a;
    }
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Test t = new Test();
        t.a();
        Test t2 = new Test();
        t2.a();
    }
}

总结代码块执行顺序：

1. 最先执行静态块，只在类加载的时候执行一次，所以一般以后实战写项目：创建工厂，数据库的初始化信息都放入静态块。
   一般用于执行一些全局性的初始化操作。
2. 再执行构造块。
3. 再执行构造器。
4. 再执行方法中的普通块。