JavaSE基础学习之面向对象

3.1面向对象概念

例：把大象装进冰箱
对于面向过程思想，强调的是过程(动作)。

• 打开冰箱
• 存储大象
• 关闭冰箱

对于面向对象思想，强调的是对象(实体)。

• 冰箱打开
• 冰箱存储
• 冰箱关闭

3.2类与对象的关系

• 类其实就是Java语言对现实生活事物的描述。
  主要有两个方面：属性和行为。
• 对象就是该类事物实实在在存在的个体。
• 类与对象的关系：
  类：事物的描述。
  对象：该类事物的实例。

public class test {
	public static void main(String[] args){
	    //通过new关键字创建一个实例
	    Car car=new Car();
	    car.num=3;
	    car.color="blue";
	    car.run();
	}
}
/**
 * 描述事物：汽车
 * 事物属性：轮子数、颜色
 * 事物行为：跑
 */
class Car{
    //轮子数
    int num;
    //颜色
    String color;
    //跑
    void run(){
        System.out.println("汽车跑起来了！");
        System.out.println(num+"-"+color);
    }
}

• 成员变量与局部变量的区别：

  1.成员变量定义在类中，整个类都可以访问。
     局部变量定义在函数、语句、局部代码块中，只在所属区域有效。

  2.成员变量存在于堆内存对象中。
     局部变量存在于栈内存方法中。

  3.成员变量随着对象的创建而存在，随着对象的消失而消失。
     局部变量随着所属区域的执行而存在，随着所属区域的结束而释放。

  4.成员变量都有默认初始化值。
     局部变量没有默认初始化值。

• 匿名对象：
  1.当对象对方法仅调用一次的时候，可以简化为匿名对象。

	new Car().run();

2.匿名对象可以作为实际参数传递。

	show(new Car());

• 参数传递

基本数据类型参数传递

引用数据类型参数传递

3.3封装

• 封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

• 好处：
  1.将变化隔离。
  2.便于使用。
  3.提高重用性。
  4.提高安全性。

• 封装原则：
  1.将不需要对外提供的内容都隐藏起来。
  2.把属性都隐藏，提供公共方法对其访问。

• 实现：

class Person{
	//私有化变量 private
	private int age;
	//创建公共的访问方法 setXxx getXxx
	public void setAge(int a){
		age=a;
	}
	public int getAge(){
		return age;
	}
}

3.4构造函数

• 概念：
  构建创造对象时所调用的函数。
• 特点：
  1.函数名与类名相同。
  2.不用定义返回值类型。
  3.没有具体返回值。
  4.对象创建后，就会调用对应的构造函数进行初始化。
• 作用：
  给对象初始化。
• 注意：
  1.默认构造函数的特点。
  2.多个构造函数是以重载的形式存在的。
• 实现：

public class test {
    public static void main(String[] args){
        Person person=new Person();
    }
}
class Person{
    private String name;
    private int age;
    //定义一个Person类的空参构造函数
    Person(){}
}

注：一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参构造函数。
如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。

3.5 this关键字

• 特点：
  this代表其所在函数所属对象的引用。
• 什么时候使用this：
  当在函数内需要用到调用该函数的对象时。

3.6 static关键字

• 作用：
  用于修饰成员(成员变量和成员函数)
• 特点：
  1.随着类加载而加载
  2.优先与对象存在
  3.被所有对象共享
  4.可以直接被类名调用
  5.static修饰的数据是共享数据，对象中存储的是特有数据。
• 注意：
  1.静态方法只能访问静态成员
  2.静态方法中不可以写this、super关键字
  3.主函数是静态的
• 实现：

public class test {
    public static void main(String[] args){
        Person person=new Person();
        person.name="小明";
        person.show();
    }
}
class Person{
    String name;
    //由于国籍都是相同的，在每个对象中都存储浪费空间，所以用static修饰，所有对象都共享。
    static String country="CN";
    public void show(){
        System.out.println(name+country);
    }
}

• 成员变量和静态变量的区别：
  1.生命周期不同
  成员变量随着对象的创建而创建，随着对象的回收而消失。
  静态变量随着类的加载而存在，随着类的消失而消失。
  2.调用方式不同
  成员变量只能被对象调用
  静态变量可以被对象调用也可以被类名调用
  3.别名不同
  成员变量也叫实例变量
  静态变量也叫类变量
  4.数据存储位置不同
  成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据
  静态变量数据存储在静态方法区中，所以也叫对象的共享数据
• 主函数：
  public static void main(String[ ] args)
  特殊之处：
  1.格式是固定的
  2.被JVM识别和调用

public:权限必须是最大的。
static:不需要对象，直接用主函数所属类名调用。
void:主函数没有具体返回值。
main:函数名，非关键字。被JVM识别的固定名称。
String[ ] args:主函数参数列表，是数组类型参数，元素都是字符串类型。

• Static关键字内存图解：
  

3.7单例设计模式

• 设计模式：
  对问题行之有效的解决方式，其实它是一种思想。
• 单例设计模式：
  解决的问题：就是可以保证一个类在内存中的对象唯一性。
  必须对于多个程序使用同一配置信息对象时，就需要保证该对象的唯一性。
• 如何保证对象的唯一性：
  1.不允许其他程序用new创建该类对象。
  2.在该类创建一个本类实例。
  3.对外提供一个方法让其他程序可以获取该对象。
• 步骤：
  1.私有化该类构造函数。
  2.通过new在本类创建一个本类对象。
  3.定义一个公有的方法，将创建的对象返回。
• 实现：

class Single{
	private static Single s=new Single();
	private Single(){}
	public static Single getInstance(){
		return s;
	}
}
class SingleDemo{
	public static void main(String[] args){
		Single s=Single.geiInstance();
	}
}

• 懒汉式：

class Single{
	private static Single s=null;
	private Single(){}
	public static Single getInstance(){
		if(s == null){
			s=new Single();
		}
		return s;
	}
}
class SingleDemo{
	public static void main(String[] args){
		Single s=Single.geiInstance();
	}
}

3.8 思维导图