java 类和对象

1.面向对象初识别

   什么是面向对象？

面 向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情 。

2.面向对象与面向过程

面向对象：可以理解为，将一件事情变成小事相似的放在一起进行打包，变成一个一个步骤。

举个例子：我们在家里吃饭，  我们，吃饭，肚子饱了 （这些就是对象）

这是个大步骤，中间小过程呢，饭菜从哪里来？

当然是我们亲爱的妈妈做饭了（所以，大家要感恩妈妈哦，任劳任怨为我们做了这么多年的饭菜）

面向过程：就是妈妈做饭的步骤。

首先 买菜——洗菜——切菜——炒菜——装盘——端上桌

3. 类与对象的基本概念

类与对象时整个面向对象中最基础的组成单元。

类：是抽象的概念集合，表示的是一个共性的产物，类之中定义的是属性和行为（方法）；
对象：对象是一种个性的表示，表示一个独立的个体，每个对象拥有自己独立的属性，依靠属性来区分不同对象。

3.1 类的定义和使用

// 创建类
class ClassName{ 
field;  // 字段(属性) 或者 成员变量
method; // 行为 或者 成员方法 
}

3.2 类的实例化

用类类型创建对象的过程，称为类的实例化 ，在 java 中采用 new 关键字，配合类名来实例化对象。

class Rabbit{
        public String name;
        public String color;
        public void eat() {
            System.out.println("like grass");
        }
}
public class Test {
    //类的实例化
    public static void main(String[] args) {
        Rabbit rabbit = new Rabbit();
        System.out.println(rabbit.name = "小灰灰");
        System.out.println(rabbit.color = "灰色");
        rabbit.eat();
    }
}

运行结果

注意：new 关键字用于创建一个对象的实例

           使用 【 . 】 来访问对象中的属性和方法.

           同一个类可以创建对个实例.

当一个实例化对象产生之后，可以按照如下的方式进行类的操作：
对象.属性：表示调用类之中的属性；
对象.方法()：表示调用类之中的方法。

4. this 引用

this 引用指向当前对象 ( 成员方法运行时调用该成员方法的对象 ) ，在成员方法中所有成员变量的操作，都是通过该

引用去访问 。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

作用：让编译器区分成员变量和形参

栗子：

public class Date {
    public int year;
    public int month;
    public int day;
        public void setDay(int year, int month, int day) { 
          this.year = year; 
          this.month = month; 
          this.day = day; 
  }
        public void printDate(){ 
            System.out.println(this.year + "/" + this.month + "/" + this.day); 
  } 
}

4.1 this引用的特性

        1. this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型

        2. this只能在 " 成员方法 " 中使用

        3. 在 " 成员方法 " 中， this 只能引用当前对象，不能再引用其他对象

        4. this是 “ 成员方法 ”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负              责将调用成员方法 对象的引用传递给该成员方法，this负责来接收

5. 对象的构造及初始化

        5.1 如何初始化对象

局部变量初始化

public static void main(String[] args) { 
    int a = 10; 
    System.out.println(a); 
}

对象初始化

public static void main(String[] args) { 
    Date d = new Date(); 
    d.printDate(); 
    d.setDate(2021,6,9); 
    d.printDate(); 
}

5.2 构造方法

        构造方法( 也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，          由编译器自动调用，并且 在整个对象的生命周期内只调用一次。

public class Date {
public int year;
public int month;
public int day; 
// 构造方法： 
// 名字与类名相同，没有返回值类型，设置为void也不行 
// 一般情况下使用public修饰 
// 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
public Date(int year, int month, int day) { 
    this.year = year; 
    this.month = month; 
    this.day = day; 
    System.out.println("Date(int,int,int)方法被调用了"); 
}
public void printDate() { 
    System.out.println(year + "-" + month + "-" + day); 
}
public static void main(String[] args) { 
    // 此处创建了一个Date类型的对象，并没有显式调用构造方法 
    Date d = new Date(2021,6,9); 
    // 输出Date(int,int,int)方法被调用了 
    d.printDate(); // 2021-6-9 
} 
}

5.2.2 特性

        1. 名字必须与类名相同

        2. 没有返回值类型，设置为 void 也不行

        3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次 (相当于人的出生，                  每个人只能出生一次)

        4. 构造方法可以重载 ( 用户根据自己的需求提供不同参数的构造方法 )

6. 封装

        6.1 封装的概念

        面向对象程序三大特性：封装、继承、多态。而类和对象阶段，主要研究的就是封装性。  

              何为封装呢？

        简单来说 就是套壳屏蔽细节。

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行 交互

6.2 访问限定符

 

public ：可以理解为一个人的外貌特征，谁都可以看得到

default: 对于自己家族中 ( 同一个包中 ) 不是什么秘密，对于其他人来说就是隐私了

private ：只有自己知道，其他人都不知道

6.3 封装扩展之包

        6.3.1 包的概念

在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类收集在一            起成为一组，称为软件 包 。

 6.3.2 导入包中的类

        使用 import语句导入包

import java.util.Date;
public class Test {
    public static void main(String[] args) { 
    Date date = new Date(); 
    // 得到一个毫秒级别的时间戳 
    System.out.println(date.getTime()); 
  } 
}

6.3.3 自定义包

基本规则

        在文件的最上方加上一个 package 语句指定该代码在哪个包中 .

        包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式 ( 例如 com.bit.demo1 ).

        包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包 , 那么会存在一个对应的路径         com/bit/demo1 来存储代码.

        如果一个类没有 package 语句 , 则该类被放到一个默认包中 .

7. static成员

static修饰成员变量

static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。

【静态成员变量特性】

1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中

2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问

3. 类变量存储在方法区当中

4. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

static修饰成员方法

Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过

静态方法来访问的。

【静态方法特性】

1. 不属于某个具体的对象，是类方法

2. 可以通过对象调用，也可以通过类名.静态方法名(...)方式调用，更推荐使用后者

3. 不能在静态方法中访问任何非静态成员变量

static成员变量初始化

静态成员变量的初始化分为两种：就地初始化 和 静态代码块初始化

8. 代码块概念以及分类

普通代码块

定义在方法中的代码块

构造块

实例代码块。构造代码块一般用于初始化实例成员变量

静态块

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。

同步代码块

9. 内部类

public class OutClass {
    class InnerClass{ 
  } 
}
// OutClass是外部类 
// InnerClass是内部类

9.1 内部类的分类

public class OutClass { 
// 成员位置定义：未被static修饰 --->实例内部类
    public class InnerClass1{ 

}
// 成员位置定义：被static修饰 ---> 静态内部类 static class InnerClass2{ }
    public void method() { 
// 方法中也可以定义内部类 ---> 局部内部类：几乎不用
      class InnerClass5{ 
}
 }
  }

【 注意事项 】

1. 外部类中的任何成员都可以在实例内部类方法中直接访问

2. 实例内部类所处的位置与外部类成员位置相同，因此也受 public 、 private 等访问限定符的约束

3. 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名

称 .this. 同名成员 来访问

4. 实例内部类对象必须在先有外部类对象前提下才能创建

5. 实例内部类的非静态方法中包含了一个指向外部类对象的引用

6. 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。