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语句。构造方法用于初始化类的实例,设置对象的初始状态。
-
-
构造方法的使用注意事项?
-
构造方法可以有多个,用于实现不同的初始化方式,这些构造方法之间通过参数列表和返回值类型进行区分。
-
在定义构造方法时,需要考虑参数的顺序和个数,确保满足类的初始化需求。
-
当调用构造方法时,会自动执行构造方法中的代码,因此要避免在构造方法中执行耗时操作或产生不必要的对象。
-