一、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();
}
}
构造函数
构造方法是一种特殊的方法:
- 定义的语法结构不同:
[访问权限修饰符] 方法名(参数列表){
......
}
修饰符:访问权限修饰符
没有返回值类型,也不写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()