1.方法
1.1概述
Java方法是语句的集合，它们在一起执行一个功能。方法是解决一类问题的步骤的有序组合，包含于类或对象中，在程序中被创建，在其他地方被引用。
方法的调用方式根据是否返回值来选择，当方法返回一个值时，方法调用通常被当做一个值；如果方法返回值是void，方法调用一定是一条语句。
方法的定义包括修饰符、返回值类型、方法名、参数类型和方法体等部分。
方法的优点包括使程序简短清晰、有利于程序维护、提高程序开发效率和提高代码重用性。
1.2 java方法分类
方法包含两部分：参数和返回值。例如计算器 加法就是一个方法 1,1 是参数 2是返回值
定义方法格式：
（1）无参无返回值
public static void 方法名(){
方法体；
}
/**
* 方法：独立具备一个功能的代码块
* 使用步骤（无参数，无返回值）：
* 1.定义方法；2.调用方法
*/
public class Demo01 {
public static void main(String[] args) {
System.out.println("开始");
method();
System.out.println("结束");
}
public static void method(){
int number=10;
if(number%2==0){
System.out.println(true);
}else {
System.out.println(false);
}
}
}
（2）无参有返回值
public static 返回值类型方法() {
方法体；
return:数值（基本类型/引用类型：与定义时的类型要一致）；
}调用：方法名（）；
public class Demo02 {
public static void main(String[] args) {
// 调用无参有返回值的方法
int result = getRandomNumber();
System.out.println("随机数是：" + result);
}
// 无参有返回值的方法：返回一个随机整数
public static int getRandomNumber() {
return (int) (Math.random() * 100);
}
}（3）有参无返回值
public static void 方法名（数据类型 参数1；数据类型 参数2，..）{
方法体；
}调用： 方法名（参数1，参数2，..） 入参顺序得相同
形参：定义方法中的小括号中的内容
实参：调用方法时给的具体参数
形参的作用是接收外部传入的数据，在方法调用的时候才分配内存空间，相当于该方法的局部变量。
public class Demo05 {
public static void main(String[] args) {
method(3,5);//参数需顺序固定
}
public static void method(int x,int y){
System.out.println("求和x+y="+(x+y));
}
}
（4）有参有返回值
public static 返回值类型 方法名（数据类型 参数1；数据类型 参数2，..）{
方法体；
return:结果（基本类型/引用类型：与定义时的类型要一致）；}
调用方法： 数据类型 接收变量名=方法名（参数1，参数2，..）；
public class Demo04 {
public static void main(String[] args) {
int x=sum(45,65);
System.out.println("x="+x);
System.out.println(sum(45,65));
}
public static int sum(int x,int y){
int sum=x+y;
return sum;
}
}
注意：
* 方法没有返回值就写void
* 有返回值就写返回值数据类型，且return返回的数据类型必须与其相同
* return返回结果结束方法，其后的代码不执行，
* 方法与方法是平级关系，不可以嵌套定义
1.3 方法的重载
满足条件：
1.必须在一个类中
2.方法名必须相同
3.参数列表必须不同(与返回值类型无关)
代码示例：
public class Demo05 {
public static void main(String[] args) {
a(1);
}
public static void a(){
System.out.println("我是不传参a方法");
}
public static void a(String str){
System.out.println("我是传String 的a方法");
}
public static void a(int i){
System.out.println("我是传int 的a方法");
}
public static void a(int i,int j){
System.out.println("我是传两个int 的a方法");
}
}
1.4 方法参数的传递
1.传递基本数据类型
* 方法中的形参改变，不影响实际参数的值
2.传递引用数据类型
* 方法中的形参改变，影响实际参数的值
代码示例：
public class Demo06 {
public static void main(String[] args) {
int number=100;
System.out.println("方法前number="+number);
method(number);//基本数据类型
System.out.println("方法后number="+number);
int []arr={3,4,5,6};
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
a(arr);//引用数据类型
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public static void method(int x){
x=200;
}
public static void a(int []arr){
arr[0]=999;
}
}
1.5小练习
写方法满足一下3点：
1.无参无返回值：判断是否是偶数
2.有参无返回值：求和
3.有参有返回值：传入三个参数，返回最大值
public class Work{
public static void main(String[] args) {
ouShu();
sum(45,12);
System.out.println(max(12,78,6));
}
public static void ouShu(){
Scanner sc=new Scanner(System.in);
int x=sc.nextInt();
if(x%2==0){
System.out.println(x+"是偶数");
}else
System.out.println(x+"不是偶数");
}
public static void sum(int num1,int num2){
int sum=num1+num2;
System.out.println(num1+"+"+num2+"="+sum);
}
public static int max(int x1,int x2,int x3){
int max1=(x1>x2)?x1:x2;
int max2=(max1>x3)?max1:x3;
return max2;
}
}
生成0-10之间随机数为下标，去与数组中的数替换
public class Work2 {
public static void main(String[] args) {
int [] arr={1,2,3,4,5,6,7,8,9,10};
random(arr);
System.out.println();
for (int i = 0; i <arr.length ; i++) {
System.out.print(arr[i]+",");
}
}
public static void random(int []arr){
int v;
for (int i = 0; i < arr.length; i++) {
v=(int)(Math.random()*arr.length);
System.out.print(" 随机数是"+v);
if (i==v)
continue;
int temp=arr[i];
arr[i]=arr[v];
arr[v]=temp;
}
}
}
2.类和对象
1.类和对象的关系
-
什么是类
-
具有相同属性和行为的对象的集合。
-
类是一种抽象的广泛的概念。例如：狗类，猫类，动物类，人类，学生类，老师类。
-
类的组成部分：
-
属性（成员变量）：就是类中有哪些描述信息。
-
行为（成员方法）：就是类可以做哪些事情。
-
-
-
什么是对象
-
对象就是某一个类型事务中的具体体现。
-
例如：水果类--苹果，动物类--狗。
-
-
类和对象的关系。
-
对象是根据类创建出来的！
-
2.定义类
-
明确类的名字
-
简名知意
-
驼峰式命名
-
-
明确类中有哪些属性
-
属性-成员变量。
-
数据类型 变量名；例如 int age;
-
-
明确类中有哪些行为
-
行为-成员方法。
-
和之前的方法定义完全一致。去掉static。
-
-
示例代码。
public class Cat { //成员变量 String name; int age; String color; //成员方法 public void eat(){ System.out.println("吃鱼"); } public void sleep(){ System.out.println("猫睡觉"); } }
3.创建对象并使用
-
创建对象的格式
-
类名 对象名=new 类名();
-
Cat cat=new Cat();
-
-
如何使用成员变量
-
对象名.成员变量名
-
cat.age=3;
-
-
如何使用成员方法
-
对象名.成员方法名();
-
cat.eat();
-
-
示例代码
public class Demo02 { public static void main(String[] args) { //创建对象 Cat cat=new Cat(); //使用成员变量。 System.out.println(cat.age); System.out.println(cat.color); System.out.println(cat.name); cat.age=1; cat.color="金色"; cat.name="张飞"; System.out.println(cat.age); System.out.println(cat.color); System.out.println(cat.name); cat.eat(); cat.sleep(); } }
4.封装
4.1private关键字
-
作用：权限修饰符（私有）。被private修饰的成员，只能在本类中访问。
示例代码：
public class Dog {
private String name ;
private int age ;
//为name赋值的方法
public void setName(String dogname){
name=dogname;
}
//取name值的方法
public String getName(){
return name;
}
}
//测试类
public class DogDemo {
public static void main(String[] args) {
// 创建对象
Dog dog =new Dog();
// dog.name 报错，由于属性私有化 ，所以无法访问类中的私有成员，所以需要用公有的get、set方法
dog.setName("张3");
String name = dog.getName();
System.out.println("name = " + name);
}
}4.2this关键字
-
作用
-
可以区分局部变量和成员变量重名问题！this修饰的是成员变量。
-
this代表的是当前对象，谁调用我 ，我就代表谁！
-
public class Dog {
private String name ;
private int age ;
//为name赋值的方法
public void setName(String name){
this.name=name;
}
//取name值的方法
public String getName(){
return name;
}
}
//测试类
public class DogDemo {
public static void main(String[] args) {
Dog dog1 =new Dog();
dog1.setName("李4");
String name1 = dog1.getName();
System.out.println("name1 = " + name1);
}
}
4.3封装总结
-
封装思想：将不想对外公开的成员隐藏起来，外界如果想要访问的话，就要提供公共的访问方式！
-
体现1：private关键字。提高代码的安全性！
-
体现2：方法。提高代码的复用性！
-
5.构造方法
5.1什么是构造方法
-
构造方法是用于创建对象的。对对象中的成员进行初始化的！
5.2构造方法的格式
权限修饰符 方法名[类名](){
}
5.3使用构造方法的注意事项
-
如果我们没有写构造方法，系统会默认提供一个空参构造方法给我们使用
-
如果我们自己写了一个构造方法，系统就不会给我们提供默认的空参构造了
-
构造方法可以重载。
public class Dog {
private String name ;
private int age ;
public Dog(String name,int age){
this.name=name;
this.age=age;
System.out.println("我是一个全参构造方法 创建对象的时候调用我了");
}
public Dog(){
System.out.println("我是一个空参构造");
}
public Dog(String name){
this.name =name ;
System.out.println("我只传了一个name");
}
//为name赋值的方法
public void setName(String name){
this.name=name;
}
//取name值的方法
public String getName(){
return name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
}
public class DogDemo {
public static void main(String[] args) {
// 创建对象
Dog dog =new Dog("zhang3",2);
String name = dog.getName();
System.out.println("name = " + name);
int age = dog.getAge();
System.out.println("age = " + age);
Dog dog1 =new Dog();
Dog dog2=new Dog("lisi");
System.out.println("name2 = " +dog2.getName());
}
}6.标准类的定义和使用
6.1类的定义
-
类的组成
-
成员变量：全部需要用priavte修饰
-
构造方法：空参构造和全参构造。
-
get方法和set方法
-
成全方法
-
代码示例写一个Student类：
public class Student {
// 1.成员变量：全部需要用priavte修饰
private String name;
private int age;
private double money;
//2.构造方法：空参构造和全参构造。
public Student() {
}
public Student(String name, int age, double money) {
this.name = name;
this.age = age;
this.money = money;
}
//3.get方法和set方法
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
public void setMoney(double money){
this.money=money;
}
public double getMoney(){
return money;
}
//4.成全方法
public void show(){
System.out.println("姓名是： "+name+"，年龄是： "+age+"他有："+money+" 钱");
}
public void study(){
System.out.println("好好学习");
}
}
6.2类的使用
-
两种创建对象的方式
-
空参构造+set方法赋值
-
有参构造创建对象时赋值
-
-
示例代码
public class StudentDemo {
public static void main(String[] args) {
//1.空参构造 + set方法赋值
Student s1 =new Student();
//为成员变量赋值
s1.setAge(17);
s1.setName("张3");
s1.setMoney(555);
s1.show();
s1.study();
System.out.println("-------------------------------");
//2.有参构造创建对象时赋值
Student s2=new Student("李四",50,66.1);
s2.show();
s2.study();
}
}
6.3总结
-
必须掌握 什么是类？ 什么是对象？类和对象的关系是什么？
-
类是面向对象编程中的一种抽象概念，它是对现实世界中某一类事物的描述，包含该类事物的共同属性和行为。对象是类的实例，是具体的存在，它具有类所定义的属性和方法。类和对象的关系是，类是对象的模板，对象是类的实例。
-
-
成员变量和局部变量的区别是什么？
-
成员变量是类中定义的变量，它属于类，作用于整个类，其生命周期从类的实例化开始到销毁结束。局部变量是定义在函数或代码块中的变量，其生命周期仅存在于函数或代码块的执行过程中。
-
-
priavte关键字有什么作用？
-
private关键字用于修饰类中的成员变量和成员方法，表示这些成员只能在类内部访问，外部无法直接访问。这有助于保护类的内部实现，防止外部对类的内部数据进行随意修改。
-
-
封装的思想是什么？
-
封装是面向对象编程的一种重要思想，它指的是将类的实现细节隐藏在类内部，只暴露有限的接口供外部使用。封装有助于提高代码的可维护性和可复用性，降低代码之间的耦合度。
-
-
构造方法如何定义？
-
构造方法是类中的一种特殊方法，其名称与类名相同，没有返回值类型，且不能使用return语句。构造方法用于初始化类的实例，设置对象的初始状态。
-
-
构造方法的使用注意事项？
-
构造方法可以有多个，用于实现不同的初始化方式，这些构造方法之间通过参数列表和返回值类型进行区分。
-
在定义构造方法时，需要考虑参数的顺序和个数，确保满足类的初始化需求。
-
当调用构造方法时，会自动执行构造方法中的代码，因此要避免在构造方法中执行耗时操作或产生不必要的对象。
-
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
