面对对象-CSDN博客

本文链接：https://blog.csdn.net/melody_zz/article/details/104818616

面对对象概念

面对对象概述

理解举例：
大象装进冰箱。

1，面向过程:
打开冰箱，储存大象，关上冰箱。（动作）

对于面向工程思想，强调的是过程。（动作）

2，面向对象：
对于面向对象思想，强调的是对象。（实体）

特点：
1，面对对象是一种常见的思想，符合人们的思考习惯
2，面对对象的出现，将复杂的问题简单化
3，面向对象的出现，让曾经在过程中的执行者，变成了对象中的指挥者

任何个体，实体都是对象。

面对对象举例

有对象用对象，没有对象创造具备功能的对象。
不断的维护对象之间的关系。

面向对象的三个特征：封装，继承多态

类与对象之间的关系

类：用java语言对现实生活中的事务进行描述。
通过类的形式来提现的。
如何描述：对于事务描述通常指关注两方面，一个是属性，一个是行为。

只要明确该事物的属性和行为并定义在类中即可。
对象：其实就是该类事物实实在在存在的个体。

类与对象之间的关系：
类：事物的描述。
对象：该类事物的实例。在Java中是通过new来创建的。

类与对象体现

描述小汽车
分析：
1，属性：轮胎数，颜色。
2，行为：运行。

class Car
{
	int num ;
	String color;
	void run ()
	{
		int num = 10 ;  (局部变量，栈内存）
		System.outprintln(num+"......"+color);
	}
}

class  CarDemo
{
	public static void main(String[] args) 
	{
		// 在计算机中创建一个car的实例。通过new关键字。
		Car c = new Car();  
		//  c就是一个类类型的引用变量，指向了该类对象。
		c.num = 4;   //给轮胎数赋值
		c.color = "red";   //给颜色赋值
		c.run();
		//要使用对象中的内容，可以通过对象.成员（只要是该事物的组成部分都可以叫做该事物的成员）的形式来完成调用
		
	}
}

细节
定义类其实就是在定义类中的成员。成员变量< - - >属性，成员函数< - - >行为.

不一定需要独立的运行能力，所以可以不需要主函数

对象的内存体现：

理解1

对象在内存中的理解2

理解3

对象的出现是为了封装数据的，
数组也可以封装数据，但是数组是同类型的数据，对象可以封装不同类型的数据

成员变量和局部变量的区别：

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

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

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

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

成员变量和局部变量的同名&显示初始化

class Car
{
	int num = 4 ;    // 显示初始化。
	String color;
	void run ()
	{
		// int num = 10 ;
		System.outprintln(num+"......"+color);
	}
}

类类型参数

// Car c1 = new Car();
// c1.num = 4;
// c1.color = "red" ;
// Car c2 = new Car();
// c2.num = 4;
// c2.color = "red" ;

Car c1 = new Car();
Car c2 = new Car();
show(c1);
show(c2);
public static void show (Car c)   // c 就是类类型的参数，类类型的变量一定指向对象，或者null
{
	c.num = 3 ;
	c.color = "balack";
	syso...
}

匿名对象

Car c = new Car();  (有名对象)
c.run();   //和 new Car().run();  一样的表达意思，方式不一样。

new Car().run();  // new Car();  匿名对象：其实就是定义对象的简写格式。

1.当对象对方法仅进行一次调用的时候，就可以简化成匿名对象。
2.匿名对象可以作为实际参数进行传递。
Car c1 = new Car();
//  show(c1);
show(new Car());   //可直接用这个方式

基本数据类型参数传递图解

引用数据类型参数传递图解

传递图解

封装

封装-代码示例

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

好处：

将变化隔离。
便于使用。
提高重要性。
提高安全性。

封装原则：

将不需要对外提供的内容都隐藏起来。
把属性都隐藏，提供公共方法对其访问。

隐藏age

封装-思想

private : 权限修饰符，私有。用于修饰成员私有的内容只在本类中有效。
注意：私有仅仅是封装的一种体现。
setXxx
getXxx

构造函数

特点：

函数与类名相同
不用定义返回值类型
没有具体返回值

作用：给对象向进行初始化
注意：

默认构造函数的特点。
返回构造函数是以重载的形式存在的。

public class ConsDemo {
    public static void main(String[] args) {
        Person p = new Person();
        //        构造函数：构建创造对象时调用的函数。作用：可以给对象进行初始化。
    }

}

class Person {
    private String name;
    private int age;

    //    定义一个Person类的构造函数。
    Person() {   //构造函数，而且是参数的。
        System.out.println("person run");
    }
    public  void speak() {
        System.out.println(name + ":" + age);
    }
}

默认构造函数

class Person {
    private String name;
    private int age;

    //    定义一个Person类的构造函数。
    Person() {   //构造函数，而且是参数的。
        System.out.println("person run");
    }

构造函数：构建创造对象时调用的函数。作用：可以给对象进行初始化。
建对象都必须要通过构造函数初始化。
一个类中如果没有定义过结构函数，那么该类中会有一个默认的空参数构造函数。
如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。

构造函数和一般函数的区别

构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。
一般函数：对象创建后，需要函数功能时才调用。
构造函数：对象创建时，会调用且只调用一次。
一般函数：对象创建后，可以被调用多次。（多次赋值）

重载

    Person() {   //构造函数，而且是参数的。
        name = "baby";
        age = 1;
        System.out.println("person run");
    }

    Person(String n) {   //一开始就有赋值
        name = n;
    }

    Person(String n, int a) {
        name = n;
        age = a;
    }

一个函数中出现多个构造函数时，必须以重载形式体现，可以对不同对象进行不同的初始化
什么时候定义构造函数：在描述事物时，该事物已存在就具备一些内容，这些内容都定义在构造函数当中。

构造函数-内存图解

    Person p2 = new Person("小强", 10);
    p2.speak();
    
    Person(String n, int a) {
    name = n;
    age = a;
}

构造函数-内存图解

构造函数-细节

class ConsDemo
{
	public static void main(String[] args)
	{
		Person p = new Person();
		p.speak();
		Person p1 = new Person("wang cai "); //构造函数只能调用一次
		p1.setName("wang wang");  //一般方法可以调用多次
		p1.setName("wang wang");  //
		p1.speak;

		Person p2 = new Person ("xiao qiang",10);
		p2.speak;
	}
}

构造函数可以调用一般函数
一般函数不可以直接调用构造函数，如果要调用就需要创建对象。
一般而言构造函数第一个单词首字母大写，一般函数第一个单词首字母小写。
构造函数里面包含return语句，但一般不写。

Person(String n) {   //一开始就有赋值
    name = n;
}

Person(String n, int a) {
    name = n;
    age = a;
public void setName(String n) {
    name = n;
}

public  void speak() {
    System.out.println(name + ":" + age);
}

this关键字

this关键字-使用场景-&this的原理图解

特点：this代表其所在函数所属对象的引用
换言之：this代本类对象的引用。
什么时候用this关键字呢？
当函数内需要用到调用该函数对象时，就用this。

    Person(String n) {   //一开始就有赋值
//        name = name;   错在局部变量和成员变量同名了
        name = n;
//        this.name = name;   局部的name赋值给这个对象的name
        
    }

class ThisDemo {
    public static void main(String[] args) {
        Person p = new Person("wang cai");
        p.speak();
    }
}

当成员变量和局部变量重名时，可以用关键字this来区分。
this：代表对象。（当前对象，）
this 就是所在函数所属对象的引用

以上面函数为例，this所在的函数是 Person(String n) ，该函数被对象调用，这个对象是 Person p ，也就是被 new Person(“wang cai”); 所调用。
所以this代表着**new Person(“wang cai”)**的引用

简单说：哪个对象调用了this所在的函数，this就代表哪个对象。

this也可以用于在构造函数中调用其它函数
注意：但是只能定义在构造函数的第一行，因为初始化动作要先执行。

this图解

this使用场景二及细节

一个类中，其所有的成员，如果要运行必须要用对象调用

构造函数和构造函数之间互相调用

Person(String name) { 
   this.name = name;
    }

Person(String name, int age) {
    this.name = name;      // this(name);  调用上面的构造函数
    this.age = age;
    }
    
public void speak() {
    System.out.println(this.name + ":" + this.age);
}

class ThisDemo {
	public static void main(String[] args) {
    	Person p = new Person("wang cai");
    	p.speak();
    	Person p1 = new Person("xiao qiang");
    	p1.speak();
	}
}

this应用

在本类中用到了本类对象，通常都用this

//判断是否是同龄人

static（静态）关键字

static关键字：用于修饰成员（成员变量和成员函数）

被修饰后的成员具备以下特点

随着类的加载而加载
优先于对象存在
被所有对象共享
可以直接被类名调用。格式：类名.静态成员
static修饰的数据是共享数据，对象中存储的是特有数据。

使用注意：

静态方法只能访问静态成员
静态方法中不可以写this，super关键字
主函数是静态的

class Person2 {
    String name;   //对象的特有数据
    static String country = "CN";  //对象的共享数据
    public void  show() {
        System.out.println(country + ":" + name);
    }
}

class StaticDemo {
    public static void main(String[] args) {
        Person2 p = new Person2();
        p.name = "小强";
        p.show();
    }
}

static共享数据

static关键字-成员变量和静态变量的区别

class Person2 {
    String name;   //对象的特有数据
//    成员变量/实例变量（对象中的变量）
    static String country = "CN";  //对象的共享数据
//    静态变量/类变量
    public void  show() {
        System.out.println(country + ":" + name);
    }
}
成员变量和静态变量的区别：
1.两个变量的生命周期不同.
  成员变量随着成员的创建而存在，随着对象的回收呗释放.
  静态变量随着类的加载而存在，随着类的消失而消失.
2.调用方式不同.
  成员对象被对象调用.
  静态变量可以被对象调用，还可以被类名调用.建议用类名调用，因为静态变量是随着类的加载而加载的，优于对象存在.
3.别名不同
  成员变量也称为实例变量.
  静态变量称为类变量.
4.数据的存储位置不同.
  成员变量数据存储在堆内存的对象中，所以也叫做对象的特有数据.
  静态变量数据存储在方法区的静态区（共享数据区/...），所以也叫对象的共享数据.

static关键字-注意事项

注意事项：
1. 静态方法只能访问静态成员。（非静态既可以访问静态，也可以访问非静态）
2. 静态方法中不可以定义this或者super关键字。（没有对象）
3. 主函数是静态的。

报错：无法在静态上下文中引用非静态变量
非静态：没有被静态修饰

class Person2 {
    String name;   //对象的特有数据
   	 static String country = "CN";  //对象的共享数据
    public static void  show() {
       	 System.out.println(country + ":" + name);
       //System.out.println(Person.country + ":" + this.name);
       //静态前面省略的是类名。
       	 （name随着对象的创建而存在，和静态是随着类的加载而加载的，所以是错误的）
    }
}

其实主函数就是创建类的对象，调用类的方法

static静态

（调用方式类，方法，对象，）

static关键字-main函数解析

//  main函数解析
class MainDemo {
    public static void main(String[] args) {  //new String[0]
        System.out.println(args);
//        [Ljava.lang.String;@14ae5a5
//        因为有哈希地址，所以有创建实体对象，而不是null
        System.out.println(args.length);
//        0
//        所以虚拟机在调用主函数的时候传入的是new String[0]，所以长度为0.
//        即创建了一个数组实体，但没有往实体里存元素，因为数组长度是0.
        System.out.println(args[0]);
//        Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
        //	at test.MainDemo.main(ConsDemo.java:117)   越界
    }
}

public static void main(String[] args)
主函数特殊之处：1.格式是固定的 2.被jvm所识别和调用。
public ：因为权限必须是最大的。
static ：不需要对象就能调用，直接用主函数所属类名调用即可
void ：主函数没有具体返回值。
main ：函数名，不是关键字，知识jvm识别的固定名字
String[] args ：这是个主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型

main函数解析

static关键字-内存图解

内存图解

class Person3 {
    private String name;
    private int age;
    static String country = "CN";

    public Person3(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person3() {

    }


    public void show() {
        System.out.println(Person3.country + ":" + this.name + ":" + this.age);
    }

    public static void method() {
        System.out.println(Person3.country);
    }
}

class StaticDemo2 {
    public static void main(String[] args) {
        Person3.method();
        Person3 p = new Person3("java", 20);
        p.show();
    }
}

什么时候用静态

1.静态变量
当分析对象中所具备的成员变量的值都是相同的。
这是这个成员就可以被静态修饰
只要数据在对象中是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。
如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。

对象都用同一个数据，这个数据就是静态数据
对象自身都具备该数据但是具体值不一样，这个数据就是特有数据

2.静态函数
函数是否用静态修饰，就参考一点：就是该函数功能是否有访问到对象中的特有数据
简单的说：从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的，如果不需要，就可以将该功能定义成静态的。
如果方法没有访问特有数据。对象的创建是没有意义的，如果定位为非静态的，则会创建对象，浪费内存空间

class Demo
{
	int age;
	static int num = 9;

	public void speak()   
	//如果变成静态则表示没有对象就能执行该方法，但如果没有对象则没有age，所以是错误的
	//所以只要看上面的 int age； 是不是静态的就可以确定这个函数要不要定义成静态的
	{
		System.out.printlin(this.age); 
		//syso(age) =  syso(this.age) 静态里是不能有this的
	}
	public static void show()
	{
		System.out.println(num);
	}
}

class StticDemo3
{
	public static void main(String[] args)
	{
		new Demo().speak();
		System.out.println("hello word!");
	}
}

static关键字-静态代码块

静态代码块：随着类的加载而执行，而且只执行一次。
作用：用于给类进行初始化。

class StaticCode
{
	static 
	{
		System.out.println("hahaha");
	}
	// 随着类的加载而执行。
	// 且只执行一次。
	// 作用：用于给类进行初始化。
	void show
	{
		System.out.println("show run");
	}
}

class StaticCodeDmeo
{
	public static void main(String[] args)
	{
		new StaticCode().show();
	}
}