第四天---java面向对象编程（一）
一、Java方法（函数）。
概念
概念：也叫函数，其实就是具有一定特殊功能的一段代码，将需要在多个位置重复使用的一组代码，定义在方法内部。
意义：1.避免了重复的代码，2，增强了程序的扩容性
定义方法：
用法：
step1：方法的定义（声明）
public static void main(String[] args) {}
语法格式
[修饰符1，修饰符2...] 返回值/void 方法名(参数列表){ ....... return } public static void main(String[] args)
示例
package com.tuling.part1; public class Demo_method { /* [修饰符1，修饰符2...] 返回值/void 方法名(参数列表){ ....... return } public static void main(String[] args)*/ // step1:定义方法 // 方法名：标识符，尽量见名知意，驼峰命名法，动宾结构 public static void getSum() { int sum = 0; for (int i = 0; i <= 10; i++) { sum += i; } System.out.println("1-10之间的和:"+sum); } // 定义有返回值的方法 public static int getSum2(){ int sum = 0; for (int i = 0; i <= 10; i++) { sum += i; } return sum;//1.结束方法的执行，2.将值返回值方法调用的地方 } // 定义有返回值有参数的方法 public static int getSum3(int num){//形参 int sum = 0; // 下面的<=号后面的注意下最好不要有空格，另外)后面一定不要有空格哦 for (int i = 0; i <=num; i++){ sum += i; } return sum; } public static void main(String[] args) { // 具有一段特殊功能的代码 // 求1-10之间的和 int sum = 0; for (int i = 0; i <= 10; i++){ sum +=i; } System.out.println("1-10之间的和:"+sum); System.out.println("hello,world"); System.out.println("hello,world"); // step2: 当前的调用 // 没有返回值的方法调用: 方法名(); // 求1-10之间的和
// 其实下面的getSum();的调用实际上是需要加上 Demo_method的，当在同一个类中调用static方法的时候，可以省略这个方法，要是调用别的时候一定要加上
getSum(); System.out.println("hello,world"); System.out.println("hello,world"); // 求1-10之间的和 getSum(); System.out.println("----------------------"); // 有返回值方法的调用, 变量 = 方法名(); int resoult2 = getSum2(); System.out.println("resoult:"+resoult2); // 有返回值有参数的方法的调用: 数据类型 变量 = 方法名(实际的参数); System.out.println("------------------------"); int result3 = getSum3( 5 );//实参 int result4 = getSum3(20 ); System.out.println("1-5的和为:"+result3); System.out.println("1-20的和为:"+result4); } }
修饰符：public statIc
返回值：一个方法执行后，返回给调用处的结果，可能有，也可能没有；
有：在方法定义的时候，写清楚方法要返回的数据的类型，
没有：void，表示这个方法执行结束之后，没有返回值给调用处
方法名：也是一种标识符，首字母小写，驼峰式命名
()：方法的标识，括号里，参数列表
{}：方法体
参数列表：方法在运算过程中的未知数据，调用者调用方法时传递。
return：将方法执行后的结果带给调用者，方法执行到return，整体方法运行结束
调用方法
setp2：方法的调用(如果一个方法只有定义，那么方法中代码并没有被执行，只有被调用了才会执行方法中的代码)
通过方法的名字进行调用
static的方法，静态方法 类名，方法名(),本类中类名可以省略 非static的方法，非静态类名 创建改类的对象，通过对象调用方法 类名，对象名 = new 类名(); 对象，方法名();
示例
package com.tuling.part1; public class Demo_method2 { // 定义一个方法，打印5次hello，world public static void print(){ for (int i = 0 ; i<5; i++){ System.out.println("hello,world"); } } public static void main(String[] args) { // step2：非static方法的调用 // 1.要创建对象 Demo_method2 obj = new Demo_method2(); // 2.用对象名，方法名(); print(); } }
方法的返回值
如果一个方式调用之后，需要返回给调用处结果，那么表示这个方式有返回值，在方法中需要使用return语句把结果返回给调用处
//方法定义 public static 返回值类型 方法名(){ //...... return 结果; } //方法的调用处 变量 = 方法名(); //变量 = 结果
如果一个方法，没有返回值，那么写void即可
return语句
A：把方法中的返回值，返回给方法的调用处
B：同时结束了这个方法的执行
注意点
1.如果一个方法声明了返回值，那么方法中一定要使用return语句的返回结果
2.定义方法的时候，声明的返回值类型，一定得和return后实际上返回的数据类型一致
3.如果一个方法声明了有返回值，如果方法中有分支语句或者循环语句，那么要保证无论执行那个分支，都要有return可以被执行到
4.如果一个方法声明没有返回值（void）那么方法中也可以使用return语句，用于强制结束方法的执行
package com.tuling.part1; public class Demo_return { //1.如果一个方法声明了返回值，那么方法中一定要使用return语句的返回结果 public static double getNum(){ return 3.4;//兼容的数据类型 会发生隐式类型转换 } //2.定义方法的时候，声明的返回值类型，一定得和return后实际上返回的数据类型一致 public static byte getNum2(){ byte b = 34; return b; } //3.如果一个方法声明了有返回值，如果方法中有分支语句或者循环语句，那么要保证无论执行那个分支，都要有return可以被执行到 public static int getNum3(){ int num = 34; // if (num>0){ // return num; // }else{ // System.out.println("num:"+num); // return 0; // } for (int i = 0; i <5; i++){ if(i==2){ return i; } } return 0; } //4.如果一个方法声明没有返回值（void）那么方法中也可以使用return语句，用于强制结束方法的执行 public static void getNum4(){ int num = 12; if(num>0){//如果符合条件那么就会进入分支，然后执行return，结束方法执行 return; } System.out.println("hello,num:"+num); } public static void main(String[] args) { getNum4(); } }
方法的相互调用
package com.tuling.part1; public class Demo_method3 { public static void test1(){ System.out.println("test1()......"); } public static void test2(){ test3(); System.out.println("test2()......."); test1(); } public static void test3(){ test1(); System.out.println("test3()......"); } public static void main(String[] args) { test1(); System.out.println("----------------------"); test2(); System.out.println("-----------------------"); test3(); } }
方法的参数
一个方法中有些数据的数值不一定，我们定义为参数，有调用处调用方法的时候，传入具体的数据
* 形式参数：形参
* 定义方式，声明的参数，用于接收调用处传来的数据
* 实际参数：实参
* 调用方法的数，实际赋值给形参的数据
示例
package com.tuling.part1; public class Demo_param { // public static void printShape(int n,int m,char c){ // 打印一个直角三角形 for (int i = 1; i <= n; i++) { for (int j = 1; j <= i; j++) { System.out.print("*"); } // 换行 System.out.println(); } } public static void main(String[] args) { // 下面有时候执行不出来需要按一下shift printShape(8,20,'c');//实参和形参要一一对应，参数的个数，类型，顺序都要一一对应 } }
方法分类
有返回值：
有参数返回值：public static返回值类型，方法名（形参列表）{}
无参数返回值：public static 返回值类型 方法名(){}
无返回值
有参数无返回值：public static void 方法名(形参列表）{}
无参数无返回值：public static void 方法名(){}
方法重载
概念：一个方法多种形式
* 同一个类中
* 方法名相同
* 参数列表必须不同（顺序，个数，类型）
与static 返回值，其他的修饰符。。。。这些无关
示例
package com.tuling.part1; public class Demo_overload { // 方法的重载：同一个类当中，方法名相同，参数列表不一样(个数，顺序，类型) public static int getSum(int a,int b){ return a+b; } // public static double getSum(double a,double b){ return a+b; } public static int getSum(int a,int b,int c){ return a+b+c; } public static void main(String[] args) { getSum(3,5); } }
递归
方法中调用方法本身，就叫做递归方法
递归方法一定有出口，逐层的向出口靠近
示例：
package com.tuling.part1; public class Demo_recursive { // public static void test1(int n) { System.out.println("test1()......."); if (n == 1) { return;//方法的出口，每一次执行的时候都是会调用一次的。 } test1(n - 1);//递归，自己调用自己 } public static int getSum(int n) { // int sum = 0; // for (int i = 0; i <= 5; i++) { // sum += i; // } // return sum; if(n==1){ return 1; } return getSum(n-1)+n; } public static void main(String[] args) { test1(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,2years,yellow,.行为：溜墙根走，奔逃的跑，喵喵叫
类和对象的关系
类是对一类事物的描述，是抽象的
对象是一类事物的实例，是具体的
类是对象的模板，对象是类的实体
类的定义
构建一个类
[修饰符] class 类名{
// 1.属性字段，Field
成员变量
// 2.成员方法，Method
行为功能
// 3.构建方法:Costructor
示例
package com.tuling.part2; //step1:定义类 public class Person{ /* [修饰符] class 类名{ // 1.属性字段，Field 成员变量 // 2.成员方法，Method 行为功能 // 3.构建方法:Costructor*/ // } //成员变量 String name;//姓名 int age;//年龄 //...... //行为:成员方法 public void eat() { //局部变量 int num = 23; System.out.println("吃饭........."); } public void sleep() { System.out.println("感觉........."); } }
创建一个对象
类名 对象名 = new 类名();
使用对象访问类中的成员
对象名，成员变量； 对象名，成员方法();
示例
package com.tuling.part2; public class testPerson { public static void main(String[] args) { // step2:创建对象 // 类名:对象名 = new 类名(); Person person = new Person(); // 访问成员变量和成员方法 // 设值 person.age = 23; person.name = "zhangsan"; // 取值 System.out.println("person对象的姓名:"+person.name); System.out.println("person对象的年龄:"+person.age); // person.eat(); person.sleep(); // 注意点:成员变量的默认值,,就是上面的如果没有给值也可以直接去访问 System.out.println("person对象的姓名:"+person.name); System.out.println("person对象的年龄:"+person.age); } }
注意点：
类中成员变量和局部成员变量不同，有默认值
基本类型
int : byte,short ,long,float,double,默认值都是0
char：的默认值“空字符”，也就是‘\u0000’,数值为0；
boolean默认值false；
引用类型，默认值都是null ，空
构建函数
构造方法是一种特殊的方法
1.定义的语法结构不同
【构造权限修饰符】 方法名（参数列表）{
}
修饰符：访问权限修饰符
没有返回值类型，也不写void
方法名：必须和类名一致
参数
没有参数；无参构造
有参数列表：有参构造
示例
Person.java
package com.tuling.part2; //step1:定义类 public class Person{ /* [修饰符] class 类名{ // 1.属性字段，Field 成员变量 // 2.成员方法，Method 行为功能 // 3.构建方法:Costructor*/ // } //成员变量 String name;//姓名 int age;//年龄 //...... // 构造函数 public Person(){//默认提供无参构造方法 System.out.println("无参构造函数........"); } // 创建对象的时候直接给参数赋值 public Person(int a,String n){ age = a; name = n; } //行为:成员方法 public void eat() { //局部变量 int num = 23; System.out.println("吃饭........."); } public void sleep() { System.out.println("感觉........."); } }
testPerson.java
package com.tuling.part2; public class testPerson { public static void main(String[] args) { // step2:创建对象 // 类名:对象名 = new 类名(); Person person = new Person(); // 访问成员变量和成员方法 // 设值 person.age = 23; person.name = "zhangsan"; // 取值 System.out.println("person对象的姓名:"+person.name); System.out.println("person对象的年龄:"+person.age); // person.eat(); person.sleep(); // 注意点:成员变量的默认值,,就是上面的如果没有给值也可以直接去访问 System.out.println("person对象的姓名:"+person.name); System.out.println("person对象的年龄:"+person.age); System.out.println("........................."); Person p2 = new Person(45,"wanglong"); System.out.println("person对象的姓名:"+p2.name); System.out.println("person对象的年龄:"+p2.age); } }
2.调用不同
1.通过new关键字调用 2.new 构造方法();
3.作用不同：专门用于创建对象的
注意点：如果一个类中当没有写有参构造方法，那么当创建对象的时候，编译器会自动天剑一个无参的构造方法，如果类中写了构造方法，那么编译器不在自动天剑无参了
THIS关键字
this代表所在类当前对象的额引用，（地址值）。即对象自己的引用
方法被那个对象调用，方法中的this代表那个对象，即谁在调用，this就代表谁
指在本类的对象可以访问本类的属性和方法
用途一：当局部变量和成员变量冲突的时候，通过this来区分
this 成员变量
示例
package com.tuling.part2; //step1:定义类 public class Person{ /* [修饰符] class 类名{ // 1.属性字段，Field 成员变量 // 2.成员方法，Method 行为功能 // 3.构建方法:Costructor*/ // } //成员变量 String name;//姓名 int age;//年龄 //...... // 构造函数 public Person(){//默认提供无参构造方法 System.out.println("无参构造函数........"); } // 创建对象的时候直接给参数赋值 // public Person(int a,String n){ // age = a; // name = n; // } public Person(int age,String name){ this.age = age; this.name = name; } //行为:成员方法 public void eat() { //局部变量 int num = 23; System.out.println("吃饭........."); } public void sleep() { System.out.println("感觉........."); } }
package com.tuling.part2; public class testPerson { public static void main(String[] args) { // step2:创建对象 // 类名:对象名 = new 类名(); Person person = new Person(); // 访问成员变量和成员方法 // 设值 person.age = 23; person.name = "zhangsan"; // 取值 System.out.println("person对象的姓名:"+person.name); System.out.println("person对象的年龄:"+person.age); // person.eat(); person.sleep(); // 注意点:成员变量的默认值,,就是上面的如果没有给值也可以直接去访问 System.out.println("person对象的姓名:"+person.name); System.out.println("person对象的年龄:"+person.age); System.out.println("........................."); Person p2 = new Person(45,"wanglong"); System.out.println("person对象的姓名:"+p2.name); System.out.println("person对象的年龄:"+p2.age); } }
解决办法就是在成员变量前加一个this就行了
this第二个用途访问本类的属性和方法
this.属性 this.方法();
习惯上可以省略this直接使用属性和方法
比如我们在添加几个成员方法
package com.tuling.part2; //step1:定义类 public class Person{ /* [修饰符] class 类名{ // 1.属性字段，Field 成员变量 // 2.成员方法，Method 行为功能 // 3.构建方法:Costructor*/ // } //成员变量 String name;//姓名 int age;//年龄 //...... // 构造函数 public Person(){//默认提供无参构造方法 System.out.println("无参构造函数........"); } // 创建对象的时候直接给参数赋值 // public Person(int a,String n){ // age = a; // name = n; // } public Person(int age,String name){ this.age = age; this.name = name; } //行为:成员方法 public void eat() { //局部变量 int num = 23; System.out.println("吃饭........."); } public void sleep() { System.out.println("感觉........."); } public void study(){ // 通过this关键字访问成员变量 System.out.println(this.name+"在学习"); } public void work(){ // 通过this关键字访问成员方法 this.study(); System.out.println("在工作-------"); } }
package com.tuling.part2; public class testPerson { public static void main(String[] args) { // step2:创建对象 // 类名:对象名 = new 类名(); Person person = new Person(); // 访问成员变量和成员方法 // 设值 person.age = 23; person.name = "zhangsan"; // 取值 System.out.println("person对象的姓名:"+person.name); System.out.println("person对象的年龄:"+person.age); // person.eat(); person.sleep(); // 注意点:成员变量的默认值,,就是上面的如果没有给值也可以直接去访问 System.out.println("person对象的姓名:"+person.name); System.out.println("person对象的年龄:"+person.age); System.out.println("........................."); Person p2 = new Person(45,"wanglong"); System.out.println("person对象的姓名:"+p2.name); System.out.println("person对象的年龄:"+p2.age); System.out.println("-------------------------------"); Person person2 = new Person(66,"liyang"); System.out.println("person2对象的姓名:"+person2.name); System.out.println("person2对象的年龄:"+person2.age); System.out.println("------------------------------"); person2.study(); person2.work(); } }
指代构造函数： this();
如果存在多个构造方法，那么this指代的构造方法要靠参数来区分：顺序，个数，类型
注意：this指向构造函数的时候只能放在第一句
示例
package com.tuling.part2; //step1:定义类 public class Person{ /* [修饰符] class 类名{ // 1.属性字段，Field 成员变量 // 2.成员方法，Method 行为功能 // 3.构建方法:Costructor*/ // } //成员变量 String name;//姓名 int age;//年龄 //...... // 构造函数 public Person(){//默认提供无参构造方法 this(23,"lixiaolong");//当我创建对象的时候默认的姓名和年龄 System.out.println("无参构造函数........"); } // 创建对象的时候直接给参数赋值 // public Person(int a,String n){ // age = a; // name = n; // } public Person(int age,String name){ this.age = age; this.name = name; } //行为:成员方法 public void eat() { //局部变量 int num = 23; System.out.println("吃饭........."); } public void sleep() { System.out.println("感觉........."); } public void study(){ // 通过this关键字访问成员变量 System.out.println(this.name+"在学习"); } public void work(){ // 通过this关键字访问成员方法 this.study(); System.out.println("在工作-------"); } }
package com.tuling.part2; public class testPerson { public static void main(String[] args) { // step2:创建对象 // 类名:对象名 = new 类名(); Person person = new Person(); // 访问成员变量和成员方法 // 设值 // person.age = 23; // person.name = "zhangsan"; // 取值 // System.out.println("person对象的姓名:"+person.name); // System.out.println("person对象的年龄:"+person.age); // person.eat(); person.sleep(); // 注意点:成员变量的默认值,,就是上面的如果没有给值也可以直接去访问 System.out.println("person对象的姓名:"+person.name); System.out.println("person对象的年龄:"+person.age); System.out.println("........................."); Person p2 = new Person(45,"wanglong"); System.out.println("person对象的姓名:"+p2.name); System.out.println("person对象的年龄:"+p2.age); System.out.println("-------------------------------"); Person person2 = new Person(66,"liyang"); System.out.println("person2对象的姓名:"+person2.name); System.out.println("person2对象的年龄:"+person2.age); System.out.println("------------------------------"); person2.study(); person2.work(); } }
面向对象的三个特性之封装
面向对象有三个特性：封装，继承，多态
封装性：尽可能隐藏对象的内部实现细节，控制对象修改及访问权限
面向对象编辑语言是对客观世界的模拟，客观世界的成员变量都是隐藏在对象的内部的，外界无法直接操作和修改
封装可以被认为是一个保护屏障，防止该类的代码和数据被其他的类随意访问，要访问该类的数据，必须通过指定的
方式，适当的封装可以使得代码更容易理解和维护，也加强了代码的安全性
1.隐藏了实现的细节
2.提高了代码的复用性
3.提高了安全性
保护细节
保护数据的安全
封装步骤：
在类中，属性的数值不安全，所以要将属性进行封装
step1：使用private修饰符来修饰属性，限于本类访问
step2：因为对象对属性的操作，赋值和取值
我们在类中提供了两个方法，分别用于改属性进行赋值和取值
赋值的方法setter：setXXX(); 比如setAge(); setName();
取值的方法setter：getXXX(); 比如getAge();l getName()
访问权限修饰符4个
public ：公共的
private: 私有的，属性，方法，只能在本类中使用
示例
package com.tuling.part2; public class Student { //step1:用访问修饰符修饰成员变量,限于本类变量 //三个成员变量 private String stuNo; private int age; private char sex; public Student(){} public Student(String stuNo,int age,char sex){ setStuNo(stuNo); setAge(age); setSex(sex); } //step2:提供设置取值相应的方法,setXXX,getXXX public void setAge(int age){ //可以设置setXXX方法当中设置一些规则 if(age<0){ System.out.println("设置的参数值不合理,请重新设置!!"); } this.age = age; } public int getAge(){ return age; } public void setStuNo(String stuNo){ //如果有限制规则,就写上.如果没有限制就直接赋值给变量 this.stuNo = stuNo; } public String getStuNo(){ return stuNo; } public void setSex(char sex){ if(sex=='男'||sex=='女'){ this.sex = sex; }else{ System.out.println("sex性别设置不合理请重新设置"); } } public char getSex(){ return sex; } //成员方法,行为 public void study(){ System.out.println("学习......."); } public void play(){ System.out.println("玩游戏......"); } //打印自己本身的属性 public void print(){ System.out.println("stuNo"+stuNo); System.out.println("age"+age); System.out.println("sex"+sex); } }
package com.tuling.part2; public class TestStudent { public static void main(String[] args) { //1.创建对象 Student student = new Student(); // student.stuNo = "001"; // student.age = 18; // student.setAge(2); // student.sex = '女'; student.setStuNo("001"); student.setAge(18); student.setSex('r'); student.print(); System.out.println("--------------------------"); Student stu2 = new Student(); // stu2.stuNo = "002"; // stu2.age = 20; // stu2.sex = '男'; stu2.print(); } }
浙公网安备 33010602011771号