一、Java方法（函数）
概念
概念：也叫函数，其实就是具有一定特殊功能的一段代码，将需要在多个位置重复使用的一组代码，定义在方法内部。
意义：1.避免了重复的代码。2.增强了程序的扩展性。
定义方法
用法：
step1：方法的定义(声明)
public static void main(String[] args) {}
语法格式：
[修饰符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 ，整体方法运行结束
调用方法
step2：方法的调用(如果一个方法只有定义，那么方法中代码并没有被执行，只有被调用了才会执行方法中的代码)
通过方法的名字进行调用。
static的方法：静态方法 类名.方法名()，本类中类名可以省略。 非static的方法：非静态方法 创建该类的对象，通过对象调用方法。 类名 对象名 = new 类名(); 对象.方法名();
示例：
//调用一个方法,如果是类的方法，可以用类名直接调用 //倘若是在本类中，那么类名可以省略 //1,static方法的调用 getSum();//方法的调用 //2，非static方法的调用 /* 创建该类的对象，通过对象调用方法。 类名 对象名 = new 类名(); 对象.方法名(); */ Demo1 demo1 = new Demo1(); demo1.test();//非static方法的调用
方法返回值
如果一个方法调用之后，需要返回给调用处结果，那么表示这个方法有返回值，在方法中需要使用return语句把结果返回给调用处。
//方法定义 public static 返回值类型 方法名(){ //..... return 结果; } //方法的调用处 变量 = 方法名(); //变量 = 结果
如果一个方法，没有返回值，那么写void即可。
return语句：
A：把方法中的返回值，返回给方法的调用处。
B：同时结束了这个方法的执行。
//求1-10的和，并且把方法中计算的结果，返回给调用处，放大10倍再打印 public static int getSum(){ int sum = 0; for(int i=1;i<=10;i++){ sum +=i; } //System.out.println("sum:"+sum); //方法调用处拿到的值和return相关，和方法体无关， return sum; }
注意点：
1.如果一个方法声明了有返回值(非void)，那么方法中一定要使用return语句返回结果。
2.定义方法的时候，声明的返回值类型，一定得和return后实际上返回的数值类型一致。
3.如果一个方法声明了有返回值，如果方法中有分支语句或者循环语句，那么要保证无论执行哪个分支，都要有return可以被执行到。
4.如果一个方法声明没有返回值(void)，那么方法中也可以使用return语句，用于强制结束方法的执行。
/** * return要注意的点 */ public class Demo2_return_2 { public static int test1(){ // return "hehe"; byte i = 20; double d = 2.3; return (int)d;//byte----->int，发生了隐式类型转换 } public static int test2(){ int age =10; if(age>10){ return 0; }else{ } return age; } public static int test3(){ for(int i=1;i<=10;i++){ // if(i==1){ // return 0;//强制结束方法，，就是说方法后面的代码都不再执行了 // } System.out.println(i); } System.out.println("hello,world"); return 0; } public static void test4(){ int age = 12; if(age>0){ return;//用于结束方法的执行，即使在没有返回值的时候，也可以用return } System.out.println("wowowo,hello,"); } public static void main(String[] args) { test3(); } }
方法相互调用
public class Demo2_2 { public static void test1(){ System.out.println("test1......."); } public static void test2(){ test1(); System.out.println("test2......"); } public static void test3(){ test2(); System.out.println("test3....."); // Demo2_2 demo22 = new Demo2_2(); // demo22.test4(); } public void test4(){ Demo2_2.test3();//本类中就直接调用，如果是其他类就，用上类名 System.out.println("test4()......"); } public static void main(String[] args) { test3(); }
方法参数
一个方法中，有些数据的数值不确定，我们定义为参数，由调用处调用方法的时候，传入具体的数据。
形式参数：形参
定义方式，声明的参数，用于接收调用处传来的数据。
实际参数：实参
调用方法的收，实际赋值给形参的数据。
示例：
/** * 方法的参数 */ 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 int getSum2(){ // int sum = 0; // for(int i=1;i<=20;i++){ // // sum +=i; // // } // // return sum; // // } public static void main(String[] args) { //求1-10的和； int result1 = getSum(10); //求1-20的和； //int result2 = getSum2(); int result2 = getSum(20); //求1-100的和； //求两个数的和 int result3 = getSum2(1,2); } }
实参一定严格匹配形参：一一对应，包括顺序，个数，类型。
方法分类
有返回值：
有参数有返回值：public static 返回值类型 方法名(形参列表){} 无参数有返回值：public static 返回值类型 方法名(){} 无返回值： 有参数无返回值：public static void 方法名(形参列表){} 无参数无返回值：public static void 方法名(){}
方法重载
概念：一个方法的多种形式。
同一个类中
方法名相同
参数列表必须不同(顺序，个数，类型)
与static，返回值，其他的修饰符。。。这些无关
示例：
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 void test1(){ System.out.println("........."); test1(); } public void test2(){ test1(); } public void test3(){ test2(); test1(); } public static void test4(int n){ System.out.println("hello,world!"); if(n==1){ return; } test4(n-1); //test4(3);.... //test4(2);.... //test4(1);.... } public static int getSum(int n){ if(n==1){ return 1; } return getSum(n-1)+n; } /* getSum(5) = getSum(4)+5 = 10+5; getSum(n-1)+n = getSum(3)+4 = 6+4; = getSum(2)+3 = 3+3; = getSum(1)+2 = 1+2; = 1 */ public static void main(String[] args) { int result = getSum(5); System.out.println("result:"+result); test4(5); } }
二、封装
面向对象思想概述
面向对象编程（OOP - Object Oriented Programing）
面向对象不是一门编程语言，也不是一种语法，而是一种编程思想。
Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下，
使用Java语言去设计、开发计算机程序。 这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面
向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算
机事件的设计思想。 它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去
操作实现。
面向过程：关注的是过程。遇到一个问题时候，“我该怎么做”，一步一步实现最终的功能即可。
面向对象：关注的是对象。遇到一个问题时候，“我该让谁来做”，这个谁就是我们要关注的对象。
类和对象
环顾周围，你会发现很多对象，比如桌子，椅子，同学，老师等。桌椅属于办公用品，师生都是人类。那么什么是
类呢？什么是对象呢？
什么是类
类 ：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该
类事物。
现实中，描述一类事物：
**属性 **：就是该事物的状态信息。
行为 ：就是该事物能够做什么。
举例：小猫。
属性：名字、体重、年龄、颜色。 行为：走、跑、叫。
什么是对象
对象 ：是一类事物的具体体现。对象是类的一个实例（对象并不是找个女朋友），必然具备该类事物的属性
和行为。
现实中，一类事物的一个实例：一只小猫。
举例：一只小猫。
属性：tom、5kg、2 years、yellow。 行为：溜墙根走、蹦跶的跑、喵喵叫。
类与对象的关系
类是对一类事物的描述，是 抽象的。
对象是一类事物的实例，是 具体的。
类是对象的模板，对象是类的实体 。
类的定义
构建一个类：
[修饰符] class 类名{ //1.属性字段：Field 成员变量 //2.成员方法：Method 行为功能 //3.构造方法：Constructor
示例：
//step1:创建一个类 public class Person { //1.属性字段：Field，也叫成员变量 String name;//姓名 int age;//年龄 String sex;//性别； //2.成员方法：Method 行为 public void eat(){ System.out.println("吃东西。。。。。"); } public void sleep(){ System.out.println("睡觉。。。。"); } }
创建一个对象：
类名 对象名 = new 类名();
使用对象访问类中的成员:
对象名.成员变量； 对象名.成员方法()；
示例：
/* 类名 对象名 = new 构造函数(); //创建对象 //对象访问属性和方法 赋值：对象.属性 = 数值 取值：对象.属性 调用方法：对象.方法名()*/ Person person = new Person(); // 创建一个对象 /* 类名 对象名 = new 构造函数(); =左边是声明一个对象， =右边是 ，创建一个对象， */ // person.name = "小A"; // System.out.println("对象的名字："+person.name); person.eat(); person.sleep(); Person p2 = new Person(); p2.name = "小强"; p2.age = 23; p2.sex = "男"; System.out.println("p2的姓名："+p2.name+",p2的年龄是："+p2.age+",p2的性别是："+p2.sex);
类中成员变量，和局部变量不同，有默认值。
基本类型：
int，byte，short，long，float，double,，默认值都是0；
char 的默认值"空字符”，也就是‘\u0000’，数值为0；
boolean默认值false；
引用类型：默认值都是null，空；
构造函数
构造方法是一种特殊的方法：
定义的语法结构不同：
[访问权限修饰符] 方法名(参数列表){ } 修饰符：访问权限修饰符 没有返回值类型，也不写void 方法名：必须和类名一致 参数： 没有参数：无参构造 有参数列表：有参构造
示例：
//默认的无参的构造方法 public Person(){ System.out.println(“这是默认的构造方法”); } public Person(String n,int a,String s){ System.out.println(“这是有参的构造方法”); System.out.println(name); System.out.println(age); System.out.println(sex); name = n; age =a; sex = s; }
调用不同：
通过new关键字调用： 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.方法();
习惯上省略this，直接用属性和方法。
public void print(){ System.out.println(“名字：”+this.name+“,性别：”+sex+“,年龄：”+age); } public void eat(){ this.print(); }
指代构造方法：this();
如果存在多个构造方法，那么this指代的构造方法要靠参数来区分：顺序，个数，类型。
注意：this指向构造函数的时候，只能放在第一句
示例：
//默认的无参的构造方法 public Person(){ System.out.println(“这是默认的构造方法”); } //有参的构造方法 public Person(String name,int age){ this();//可以调用无参的构造方法 this.name = name; this.age = age; } // public Person(String sex,int age){ // // } public Person(String name,int age,String sex){ this(name,age);//有参的构造方法 System.out.println(“这是有参的构造方法”); // System.out.println(name); // System.out.println(age); // System.out.println(sex); // this.name = name; // this.age =age; this.sex = sex; }
面向对象三大特性之封装性
面向有三大特性：封装，继承，多态
封装性：尽可能隐藏对象的内部实现细节，控制对象的修改及访问的权限。
面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。
封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的
方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。
1，隐藏了实现的细节；
2，提高了代码的复用性；
3，提高了安全性；
保护细节。
保护数据的安全。
封装步骤：
在类中，属性的数值不安全。所以要将属性进行封装。
step1：使用private修饰符来修饰属性。限于本类中访问
step2：因为对象对属性的操作：赋值和取值
我们在类中提供两个方法，分别用于给属性进行赋值和取值。
赋值方法setter：setXXX()；譬如setAge()，setName()
取值方法getter：getXXX()； 譬如getAge()，getName()
访问权限修饰符：4个
public：公共的
private：私有的，属性，方法。。只能在本类中使用。
示例：
/** * * 属性的封装： * step1:用private修饰属性，让属性只能在本类中访问 * step2:提供setXXX方法，设置成员变量的值 * step3:提供getXXX方法，获取成员变量的值 / public class Person { private String name; //private修饰符，就只能在本类中访问 private int age; / 赋值，是setXXX / public void setAge(int age){ if(age<0){ System.out.println(“年龄不能为负数”); return; } this.age = age; } / 取值：getXXX */ public int getAge(){ return this.age; } public void setName(String name){ if(name.length()>6||name.length()<2){ System.out.println(“姓名太长或者太短”); return ; } this.name = name; } public String getName(){ return this.name; } public Person(){} public Person(String name,int age){ this.name = name; this.age = age; } public void eat(){ System.out.println(“吃东西。。。。”); } }
测试：
public class Demo3 { public static void main(String[] args) { Person p1 = new Person(); //p1.name = “成龙”; p1.setName(“成龙”); //p1.age = -30; p1.setAge(90); System.out.println(“p1姓名：”+p1.getName()+“,p1的年龄：”+p1.getAge()); } }
