【Java基础】面向对象（一）

一、Java方法（函数）

概念

概念：具有一定特殊功能的一段代码，将需要在多个位置重复使用的一组代码，定义在方法内部，也叫作函数。

意义：1、避免了重复的代码；2、增强了程序的可扩展性。

定义方法

语法格式：

[修饰符1, 修饰符2...] 返回值类型/void 方法名(参数列表) {
	......
	return
}

示例：

//求1-10的和
public static void getSum() {
	//方法体
	int sum = 0;
	for (int i = 1; i <= 10; i++) {
		sum += i;
	}
	System.out.println("sum:" + sum);
}

修饰符：public，static.
返回值：一个方法执行之后，返回给调用处的结果。可能有，也可能没有。
①有：在方法定义的时候，写清楚方法要返回的数据的类型。
②没有：void，表示这个方法执行结束之后，没有返回值给调用处。
方法名：也是一种标识符。首字母小写，驼峰式命名。
()：方法的标志，括号里放参数列表。
{}：方法体。
参数列表：方法在运算过程中的未知数据，调用者调用方法时传递。
return ：将方法执行后的结果带给调用者，方法执行到 return ，整体方法运行结束。

调用方法

如果一个方法只有定义，那么方法中代码并没有被执行，只有被调用了才会执行方法中的代码。

通过方法的名字进行调用

static的方法：静态方法
	类名.方法名()，本类中类名可以省略。
非static的方法：非静态方法
	创建该类的对象，通过对象调用方法。
	类名 对象名 = new 类名();
	对象.方法名();

示例：

	//调用一个方法,如果是类的方法，可以用类名直接调用
	//倘若是在本类中，那么类名可以省略
	//1,static方法的调用
	getSum(); //方法的调用
	//2，非static方法的调用
	/*
	创建该类的对象，通过对象调用方法。
	类名 对象名 = new 类名();
	对象.方法名();
	*/
	Demo1 demo1 = new Demo1();
	demo1.test(); //非static方法的调用

方法返回值

如果一个方法调用之后，需要返回给调用处结果，那么表示这个方法有返回值，在方法中需要使用return语句把结果返回给调用处。

//方法的定义
public static 返回值类型 方法名(){
	//.....
	return 结果;
}

//方法的调用
变量 = 方法名(); //变量 = 结果

如果没有返回值，那么写void即可。

示例：

//求1-10的和，并且把方法中计算的结果，返回给调用处，放大10倍再打印
public static int getSum() {
	int sum = 0;
	for (int i = 1; i <= 10; i++){
		sum += i;
	}
	return sum;
}

注意：
1、如果一个方法声明了有返回值(非void)，那么方法中一定要使用return语句返回结果。
2、定义方法的时候，声明的返回值类型，一定得和return后实际上返回的数值类型一致。
3、如果一个方法声明了有返回值，如果方法中有分支语句或者循环语句，那么要保证无论执行哪个分支，都要有return可以被执行到。
4、如果一个方法声明没有返回值(void)，那么方法中也可以使用return语句，用于强制结束方法的执
行。

方法参数

一个方法中，有些数据的数值不确定，我们定义为参数，由调用处调用方法的时候，传入具体的数据。

• 形式参数：形参
• 定义方式，声明的参数，用于接收调用处传来的数据。
• 实际参数：实参
• 调用方法的时候，实际赋值给形参的数据。

示例：

//方法参数
public class Demo {
	public static int getSum(int n) {
		int sum = 0;
		for(int i = 1; i <= n; i++) {
			sum += i;
		}
		return sum;
	}
	
	public static int getSum2(int a, int b) {
		return a + b;
	}

	public static void main(String[] args) {
		//求1-10的和；
		int result1 = getSum(10);
		
		//求1-20的和；
		int result2 = getSum(20);
	}
}

实参一定严格匹配形参：一 一对应，包括顺序，个数，类型。

方法分类
有返回值：
有参数有返回值：public static 返回值类型 方法名(形参列表){}
无参数有返回值：public static 返回值类型 方法名(){}
无返回值：
有参数无返回值：public static void 方法名(形参列表){}
无参数无返回值：public static void 方法名(){}

方法重载

概念：一个方法的多种形式。

• 同一个类中
• 方法名相同
• 参数列表必须不同(顺序，个数，类型)

与static，返回值，其他的修饰符。。。这些无关

示例：

public class test {
    public class Demo_overload {
        public static void test1() {
        }

        public static void test2() {
        }

        public void test3() {
        }

        public static int getSum(int a, int b) {
            return a + b;
        }

        public static double getSum(double a, double b) {
            return a + b;
        }

        public void getSum(int c) {
        }

        public static void main(String[] args) {
            int result = getSum(1, 2);
            double result2 = getSum(2.3, 4);
        }
    }
}

递归

方法中调用方法本身，就叫做递归方法。

递归方法一定有出口的，逐层的向出口靠近。

示例：

public class Demo_recursion {
	//无返回值的递归方法
    public static void test1(int n) {
        System.out.println("test1()......");
        if (n == 1) {
            return;//方法的出口
        }
        test1(n - 1);//递归，自己调用自己,递归一定要有出口
    }

    //有返回值的递归方法
    public static int getSum(int n) {
        if (n == 1) {
            return 1;
        }
        return getSum(n - 1) + n;
    }

    public static void main(String[] args) {
        test1(5);
        //用递归的方式来求1-5之间的和
		//getSum(5)---->getSum(4)+5;
		//getSum(4)---->getSum(3)+4;
		//getSum(3)---->getSum(2)+3;
		//getSum(2)---->getSum(1)+2;
		//getSum(1)----->return 1;

        System.out.println("------------------------");
        int sum = getSum(5);
        System.out.println("sum:" + sum);
    }
}

二、封装

面向对象思想概述

面向对象编程（OOP - Object Oriented Programing）
面向对象不是一门编程语言，也不是一种语法，而是一种编程思想。

Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下，使用Java语言去设计、开发计算机程序。 这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。 它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。

面向过程：关注的是过程。遇到一个问题时候，“我该怎么做”，一步一步实现最终的功能即可。
面向对象：关注的是对象。遇到一个问题时候，“我该让谁来做”，这个谁就是我们要关注的对象。

类和对象

环顾周围，你会发现很多对象，比如桌子，椅子，同学，老师等。桌椅属于办公用品，师生都是人
类。那么什么是类呢？什么是对象呢？
什么是类
类 ：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。

现实中，描述一类事物：
属性 ：就是该事物的状态信息。
行为 ：就是该事物能够做什么。
举例：小猫
属性：名字、体重、年龄、颜色。
行为：走、跑、叫。

什么是对象
对象 ：是一类事物的具体体现。对象是类的一个实例（对象并不是找个女朋友），必然具备该类事物的属性和行为。

现实中，一类事物的一个实例：一只小猫。
举例：一只小猫
属性：tom、5kg、2 years、yellow。
行为：溜墙根走、蹦跶的跑、喵喵叫。

类与对象的关系

类是对一类事物的描述，是 抽象的。
对象是一类事物的实例，是 具体的。

类是对象的模板，对象是类的实体 。

类的定义

语法格式：

[修饰符] class 类名{
	//1.属性字段：Field
	成员变量
	//2.成员方法：Method
	行为功能
	//3.构造方法：Constructor
}

示例：

//step1:定义类
public class Person {
    //属性，成员变量
    String name;//姓名
    int age;//年龄
    //.....

    //构造函数
    public Person() {
    	//默认会提供无参构造方法
    }

    //有参构造：就是在创建对象的时候可以直接给成员变量赋值
    public Person(int a,String n){
        age = a;
        name = n;
    }

    //行为:成员方法
    public void eat() {
        System.out.println("吃饭......");
    }

    public void sleep() {
        System.out.println("睡觉......");
    }
    
}

创建一个对象：

类名 对象名 = new 类名();

使用对象访问类中的成员:

对象名.成员变量；
对象名.成员方法()；

示例：

public class TestPerson {
    public static void main(String[] args) {
        //step2:创建对象
        //类名 对象名 = new 类名();
        Person person = new Person();
        
        //访问成员变量和成员方法
        //设值
        person.age = 23;
        person.name = "zhoujie";

        //取值
        System.out.println("person对象的姓名：" + person.name);
        System.out.println("person对象的年龄：" + person.age);

        //调用成员方法
        person.eat();
        person.sleep();
    }
}

构造函数

构造方法是一种特殊的方法：

1. 定义的语法结构不同：

[访问权限修饰符] 方法名(参数列表){
	......
}

修饰符：访问权限修饰符
没有返回值类型，也不写void
方法名：必须和类名一致
参数：
没有参数：无参构造
有参数列表：有参构造

• 调用不同：

1 通过new关键字调用：
2 new 构造方法();

• 作用不同：专门用于创建对象的。

注意点：如果一个类中，没有写构造方法，那么当创建对象的时候，编译器会自动添加一个无参的构造方法。但是如果类中写了构造方法，那么编译器不再自动添加无参了。

this关键字

this代表所在类的当前对象的引用（地址值），即对象自己的引用。

方法被哪个对象调用，方法中的this就代表那个对象。
即，谁在调用，this就代表谁。

• 指代本类的对象，可以访问本类的属性和方法

用途一：当局部变量和成员变量命名冲突的时候，通过this来区分

this.成员变量

示例：

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

用途二：访问本类的属性和方法

this.属性
this.方法()

示例：

public void print() {
	System.out.println("名字：" + this.name + ",性别：" + sex + ",年龄：" + age);
}
public void eat() {
	this.print();
}

习惯上省略this，直接用属性和方法。

• 指代构造方法：this()

如果存在多个构造方法，那么this指代的构造方法要靠参数来区分：顺序，个数，类型。

注意：this指向构造函数的时候，只能放在第一句。

示例：

public class Person {
	String name;
	int age;

    //默认的无参的构造方法
    public Person() {
        System.out.println("这是默认的构造方法");
    }

    public Person(String name, int age) {
        this();//可以调用无参的构造方法
        this.name = name;
        this.age = age;
    }

    public Person(String name, int age, String sex) {
        this(name, age);//有参的构造方法
        System.out.println("这是有参的构造方法");
        this.sex = sex;
    }
}

面向对象三大特性之封装性

面向有三大特性：封装，继承，多态

封装性：尽可能隐藏对象的内部实现细节，控制对象的修改及访问的权限。

面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

1，隐藏了实现的细节；
2，提高了代码的复用性；
3，提高了安全性；

保护细节。
保护数据的安全。

封装步骤：
在类中，属性的数值不安全。所以要将属性进行封装。

step1：使用private修饰符来修饰属性，限于本类中访问；
step2：因为对象对属性的操作：赋值和取值。
我们在类中提供两个方法，分别用于给属性进行赋值和取值。
赋值方法setter：setXXX()；譬如setAge()，setName()
取值方法getter：getXXX()； 譬如getAge()，getName()