JavaSE第三章 面向对象 POP 和 java类

3 第三章面向对象

3.1 POP和OOP

1. 面向过程：procedure oriented programming 缩写 POP, 分析问题, 找出解决问题的步骤, 然后按步骤一步一步实现.

   • POP适合处理简单的问题, 直接关注流程.

2. 面向对象：object oriented programming 缩写 OOP, 以分类的方式思考和解决问题.

   • OOP适合处理复杂的事情，先使用面向对象的方式对整体关系作出分类，然后，根据不同的类深入细节的处理。

3. 两者之间的关系

   ​ 面向对象无法取代面向过程，他们是相辅相成的。面向对象关注于从宏观上把握事物之间的关系，在具体到如何实现某个细节时，仍然采用面向过程的思维方式。面向对象如果离开了面向过程，就无法实现真正的落地，成为无源之水。

3.2 Java类

3.2.1 what

类是一个模板, 它描述了某个事物的属性和行为.

类是客观世界中某事物的一些基本特征的抽象.

3.2.2 类的结构

变量成员(属性)

构造方法

成员方法

块

内部类

3.2.3 类的实例—对象

创建对象

//对象
Student tom = new Student();

Student misa = new Student();

对象的使用

// 同一类的每个对象有不同的成员变量存储空间。
// 调用对象属性
tom.name;

misa.name;

// 调用类方法
// 同一类的每个对象共享该类的方法。
tom.getUp();

misa.getUp();

总结

类是某一事物的抽象概念, 是一个模型.

对象是类的一个具体存在, 是一个实例.

3.2.4 类中变量

成员变量

• 定义在类中,并在方法体之外的变量;
• 成员变量会在类创建对象时复制一份到对象中去
• 在类中都可以使用, 其作用范围为整个类体。

局部变量

• 在方法, 块或构造方法中声明定义的变量叫做局部变量.
• 变量的声明和初始化都在方法中, 方法结束后, 变量就会自动销毁.

静态变量

用static修饰的变量叫做静态变量(类变量), 它也声明在类中方法体之外

静态变量与非静态变量的区别

1. 出现时间不同:
   • 静态变量只有一个, 在类加载时就已经存在 ;
   • 非静态变量在创建对象时才会出现 ;
2. 存储地点(出现地点)不同:
   • jvm虚拟机在加载类的过程中为静态变量分配内存 , 静态变量存储在方法区中的静态区
   • 每创建一次对象，就会为变量分配一次内存，非静态变量存储在堆空间中
3. 访问方式不同:
   • 静态变量被所有实例对象共享
   • 非静态变量只能在单个对象中访问, 不能共享
4. 生命周期不同:
   • 静态变量会在jvm虚拟机关闭(程序执行完成之后)之后消失, 取决于类的生命周期,
   • 非静态变量会随着对象的回收, 而消失. 取决于实例对象的生命周期.

3.2.5 方法

构造方法

用来创建对象的方法

会在创建对象(对象实例化)时调用

• 构造方法与类名同名, 无返回值 .也无需void修饰.
• 一个类可以有多个构造方法,但方法参数不同;
• 每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法,但是只要在一个Java类中定义了一个构造方法后，默认的无参构造方法即失效。

   /*
         构造方法  无参
     */
    public Student(){

    }
//  有参 构造方法
    public Student(String name, String sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

成员方法

定义在类中。这种方法在创建对象的时候创建.

静态方法

用static修饰的方法. 只能用类名来调用.

方法的重载

方法的重载是指一个类中可以定义有相同的名字，但参数不同的多个方法。调用时会根据参数的不同,选择不同的重载方法

/**
     * 吃早餐
     */
	//和返回值无关
	//参数数量不同
    public void haveBreakfast() {
        System.out.println("吃早餐");
    }
	//参数类型不同	
    public void haveBreakfast(String type1 ,String type2) {
        System.out.println(this.name + " 吃 "+type1+" 和 " +type2);
    }

	//参数顺序不同
    public void haveBreakfast(String type ,int count) { 
        System.out.println(this.name + " 吃 "+count+" 个 " +type);
    }
	//参数顺序不同
    public void haveBreakfast(int count,String type) { 
        System.out.println(this.name + " 吃 "+count+" 个 " +type);
    }

3.2.6 对象的引用

对象

Car car= new Car();//创建对象
Car car1;
car1 = new Car();

1. new Car(); 调用car的构造方法, 在堆空间中创建一个对象.
2. Car car 是创建了一个Car类型的引用变量, 它存储在栈空间.
3. = 赋值运算符把右边的对象赋给car引用变量.

new Car(); 在堆空间中创建了一个对象实体, 但没有名字, 就无法访问它.

所以就要使用对象引用变量来访问对象实体.

基本类型与引用类型的区别

基本数据类型	变量	在栈空间存值
引用数据类型	对象	在栈空间存引用变量. 在堆空间存储对象属性

值传递与引用传递

值传递: 只传递变量中的值, 不传递变量.

引用传递: 它传递的其实不是值, 而是在栈空间存储的引用变量的地址

基本类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象本身 。

3.2.7 static关键字

概念:

static 静态 , 可以用来修饰类的属性, 方法 , 代码块 , 内部类.

特点:

1. 类加载的时候加载, 类加载完成之后, static 就已经存在.

2. 优先于对象被加载声明

3. 修饰的成员,属于类本身, 被所用对象共享

4. 可以不用创建对象, 可以直接用类名调用

使用:

可以用对象调用,也可以使用类名调用;

static修饰的成员只能访问静态成员, 不能访问非静态成员

3.2.8 代码块

实例块

每次创建对象时调用, 和构造方法差不多

{

}

静态块

只在加载类的时候调用一次.

static{

}

3.2.9 初始化执行顺序

1. 加载类, 到方法区中 (加载类)
2. 静态变量初始化 , 存储到静态区中(静态变量)
3. 静态块开始执行, 存储到静态区中(静态块)
4. 创建对象时, 初始化成员变量; (成员变量)
5. 创建对象时, 执行实例块. (实例块)
6. 再执行构造方法,(构造方法)
7. 成员方法 , (方法代码块)

3.2.10 包 package

概念: 实质就是文件夹

作用: 分类, 管理类.

体现:

1. 导入外部包或类 , import
2. 避免类重名 重名时可使用全类名
3. 按照不同的功能管理类
4. 访问控制权限

包的命名规范

/**
*第一级项目类型: com , org, edu等等
*第二级公司或组织名: baidu, sun, oracle, misakora等等
*第三级项目名: misakora
*第四级功能模块的名称: controller, servlet, dao, mapper等等
*第五级系统用户: .......
*第六级用户和角色: ......
*.......
*/

3.2.11 访问权限修饰符

修饰符	含义	使用范围
public	公共的	类, 属性, 方法
protected	受保护的	属性, 方法
(default)	默认	类, 属性, 方法
private	私有的	属性, 方法

	同类	同包中	不同包子类	不同包中类
public	true	true	true	true
protect	true	true	true	false
default	true	true	false	false
private	true	false	false	false

package com.misakora.project.javaoop.day9;
public class Demo1 {
    /**
     * public    可用于 类 属性 方法
     * protected 可用于 属性  方法
     * default  可用于 类 属性 方法
     * private 可用于 属性  方法
     */
    public int publicNum;
    protected int proNum;
    int num;
    private int privateNum;

    public void test(){
        Demo1 demo1 = new Demo1();
        System.out.println(demo1.publicNum);
        System.out.println(demo1.proNum);
        System.out.println(demo1.num);
        System.out.println(demo1.privateNum);
    }

}

// 同包不同类
package com.misakora.project.javaoop.day9;
public class Demo3 {

    public void test(){
        Demo1 demo1 = new Demo1();
        System.out.println(demo1.publicNum);
        System.out.println(demo1.proNum); 
        System.out.println(demo1.num);
        System.out.println(demo1.privateNum);//报错 //私有  只能同类访问
    }
}

//另一个包中的类
package com.misakora.project.javaoop.test;

import com.misakora.project.javaoop.day9.Demo1;

public class Demo2 {

    public void test(){
        Demo1 demo1 = new Demo1();
        System.out.println(demo1.publicNum);
        System.out.println(demo1.proNum);//报错 //受保护的  ,只能同包访问,和子类访问
        System.out.println(demo1.num);//报错 // 默认   只能同包访问
        System.out.println(demo1.privateNum);//报错 //私有  只能同类访问
    }
}