1. 方法
1.1 什么是方法
方法其实类似于 C语言 中的函数,能够被重复使用从而来减少代码量。
比如来写一个打印 n的阶乘的方法:
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int ret = fact(n);
System.out.println(ret);
}
//方法 fact,与C中的函数类似
// 1! + 2! + 3! + 4! + 5! + ..... + n! (阶乘的和)
public static int fact(int n){
int m = 1, sum = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
m *= j;
}
sum += m;
m = 1;
}
return sum;
}
从上述代码,不难看出方法也有返回值,传参,出了Java和C的写法不同,主要的要素都是相同的。当然,方法也可以没有返回值,比如 void。
1.2 方法的重载
在Java中,如果多个方法的名字相同,参数列表不同,则称该几种方法被重载了。
重载的特点:
1. 方法名必须相同
2. 参数列表必须不同(包括参数类型,个数,顺序等等)
3. 返回值类型是否相同无关
public static void main2(String[] args){
int a = add(1, 2); // 调用add(int, int)
double b = add(1.5, 2.5); // 调用add(double, double)
double c = add(1.5, 2.5, 3.5); // 调用add(double, double, double)
System.out.println(a + b + c);
}
public static int add(int x, int y) {
return x + y;
}
public static double add(double x, double y) {
return x + y;
}
public static double add(double x, double y, double z) {
return x + y + z;
}
上述代码中的方法都是add(),但是它们或者参数不同,或者数量不同,因此可以构成方法的重载
因此这样的情况是可以运行的。
2. 类 和 对象
2.1 什么是类,对象
类 是Java中的关键部分,如果是和 C语言中哪部分比较像,我觉得是结构体 struct。
类是用来对一个实体(对象)来进行描述的,主要描述该实体(对象)具有哪些属性(比如狗的外观,样貌等),哪些行为/功能(吃饭,睡觉,玩儿等等),描述完成后通过对类进行实例化计算机就可以识别了。
关于对象,大家可能听说过,Java是一门面向对象的语言,而C语言是面向过程的语言。我们可以拿洗衣服来举例:
C语言就像是纯手洗,拿衣服--放进盆中--倒入洗衣粉--自己亲手洗--拧干。
Java就像是用全自动洗衣机来洗,只需要 放衣服和洗衣粉--洗衣机洗衣服,甩干。
所以,面向对象其实是一种解决问题的思想,依靠对象之间的交互来完成一件事。C语言更像是亲力亲为一件事,Java更像是有一个人或者机器来帮助你完成一件事,二者都有用处,并无好坏之分。
2.2 类的使用
类的定义格式:class + 类名 { 内容 }
class WashMachine{
public String brand; // 品牌
public String type; // 型号
public double weight; // 重量
public double length; // 长
public double width; // 宽
public double height; // 高
public String color; // 颜色
//成员方法:可不加static
public void washClothes(){ // 洗衣服
System.out.println("洗衣功能");
}
public void dryClothes(){ // 脱水
System.out.println("脱水功能");
}
public void setTime(){ // 定时
System.out.println("定时功能");
}
}
上述代码就是一个定义好的类,从内容可以看出是关于洗衣机的。
其中包括了 成员方法 和 成员变量,成员变量是一种变量,只是存在于类中;而成员方法也是存在于类中才称作成员方法。其中成员方法中可以传入参数。
2.3 类的实例化
我们再定义一个狗类:
class PetDog {
// 狗的属性
public String name;//名字
public String color;//颜色
// 狗的行为
public void barks() {
System.out.println(name + ": 旺旺旺~~~");
}
public void wag() {
System.out.println(name + ": 摇尾巴~~~");
}
}
也是一个很简单的类,当然可以在里面添加很多东西,比如成员变量可以添加 品种,年龄等等。
那么,写好的类怎么实现,这就要涉及类的实例化。
class PetDog {
// 狗的属性
public String name;//名字
public String color;//颜色
// 狗的行为
public void barks() {
System.out.println(name + ": 旺旺旺~~~");
}
public void wag() {
System.out.println(name + ": 摇尾巴~~~");
}
}
//public 修饰的类的名字和文件名相同
public class Dog {
//在main方法中可以实例化类
public static void main(String[] args){
//通过new关键字,实例化了一个PetDog对象
PetDog dog = new PetDog();
//dog是一个引用,指向了PetDog
//通过对象的引用,访问其属性
dog.name = "阿黄";
dog.color = "黄色";
System.out.println(dog.name);
System.out.println(dog.color);
//调用成员方法
dog.barks();
dog.wag();
//可以再实例化一个dog2
PetDog dog2 = new PetDog();
dog2.name = "小黑";
dog2.color = "黑色";
System.out.println(dog2.name);
System.out.println(dog2.color);
dog2.wag();
dog2.barks();
}
}
上述就是一个类的构建和实例化,用类类型创建对象的过程,称为类的实例化,在java中采用new关键字,配合类名来实例化对象。
2.4 this 引用
为什么会提到 this 这个关键词,那是因为有时候会出现以下情况:
class Date {
public int year;
public int month;
public int day;
public void setDay(int y, int m, int d){
year = y;
month = m;
day = d;
}
public void printDate(){
System.out.println(year + "/" + month + "/" + day);
}
}
public class TestDate {
public static void main(String[] args) {
// 构造三个日期类型的对象 d1 d2 d3
Date d1 = new Date();
Date d2 = new Date();
Date d3 = new Date();
// 对d1,d2,d3的日期设置
d1.setDay(2020, 9, 15);
d2.setDay(2020, 9, 16);
d3.setDay(2020, 9, 17);
// 打印日期中的内容
d1.printDate();
d2.printDate();
d3.printDate();
}
}
在上述代码中,我们在类的成员方法中传入三个参数,year,moon 和 day,然后赋值,再实例化对象,一切都没有问题。但是如果传入的参数名字和成员变量名字相同时,就会出现问题。
public void setDay(int year, int month, int day){
year = year;
month = month;
day = day;
}
比如像这样,这时候系统就会分不清到底是谁给谁赋值,谁是成员变量,就会报错。
这个时候,this 关键字就可以发挥作用了。
class Date {
public int year;
public int month;
public int day;
//this 避免 形参名不小心与成员变量名相同
public void setDay(int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
}
public void printDate(){
System.out.println(this.year + "/" + this.month + "/" + this.day);
}
}
public class Class_6_lei {
public static void main(String[] args) {
// 构造三个日期类型的对象 d1 d2 d3
Date d1 = new Date();
Date d2 = new Date();
Date d3 = new Date();
// 对d1,d2,d3的日期设置
//this引用的是调用成员方法的对象
d1.setDay(2020, 9, 15);
d2.setDay(2020, 9, 16);
d3.setDay(2020, 9, 17);
// 打印日期中的内容
d1.printDate();
d2.printDate();
d3.printDate();
}
}
可以看到,使用 this. 就可以消除这种问题了,因为 this 引用的是调用成员方法的对象,所以可以实例化多个对象,this 也可以分辨出来,即哪个对象调用就是哪个对象的引用类型。
但需要注意的是,this 只能在类的成员方法中使用。
2.5 对象的初始化
如何初始化对象呢,这里有三种方法:1.构造方法 2.默认初始化 3.就地初始化
2.5.1 构造方法
比如我们先创建一个学生类,然后生成一个构造方法(IDEA中鼠标右键可以一键生成)
class Student{
public String name; // private修饰的成员变量,只能在该类中进行修改
public int age;
public Student(){
this("lwb",25); //构造方法中,可以通过this调用其他构造方法来简化代码
System.out.println("不带参数的构造方法");
}
public Student(int age) { //鼠标右键一键生成构造方法
this.age = age;
System.out.println("带有一个参数的构造方法");
}
//构造方法
public Student(String name, int age){
this.name = name;
this.age = age;
System.out.println("带有两个参数的构造方法");
}
@Override //对象的打印 鼠标右键--生成--toString()
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}'; //可以自己编辑内容
}
//成员方法 区别:void
public void Study(){
System.out.println("姓名:" + this.name + " " + "年龄:" + this.age + " 正在学习");
}
}
可以看到,上述代码中一共有三个构造方法,分别是:不带参数,带一个参数和带两个参数。
而且因为三个构造方法还满足了方法的重载:名字相同,参数列表不同,因此构成了方法重载。
另外,如果用户没有显式定义,编译器会生成一份默认的构造方法,生成的默认构造方法一定是无参的。
还有一点是,构造方法中,可以通过this调用其他构造方法来简化代码,比如代码中的,不带参数的构造方法中用 this () 调用了带有两个构造方法中的参数,简化了代码,这样在main方法中就可以不用在给参数赋值了。
2.5.2 默认初始化
当局部变量没有初始化的时候,系统是会报错的,比如:
public static void main(String[] args) {
int a;
System.out.println(a); // Error:(26, 28) java: 可能尚未初始化变量a
}
但是成员变量没有初始化时,系统会默认初始化,比如:
class Date_1{
public int year;
public int month;
public int day;
public Date(int year, int month, int day) {
// 成员变量在定义时,并没有给初始值
System.out.println(this.year);
System.out.println(this.month);
System.out.println(this.day);
}
}
public class Date {
public static void main(String[] args) {
Date d = new Date(2021,6,9);
}
}
系统会根据变量的类型默认初始化:
比如:int 类型会初始化为 0; boolean 类型会初始化为 false 等等。
2.5.3 就地初始化
就地初始化很简单,就是在声明成员变量时就定义好初始值:
class Date_1{
public int year = 1900;
public int month = 1;
public int day = 1;
}
这样做的缺点很明显,没有构造方法,或者在main方法中通过 new 关键字创建方便。
小结:
这次主要写了 Java 中的关键部分,类和对象。下面会写到与类相关的更重要的内容,封装,继承,多态 以及接口。这些也是和C语言不同的部分。