java-day17
目录
上午
方法调用
1、非静态方法
没有使用static关键字修饰的方法，调用这种方法一定要是有对象，非静态方法是属于对象的，非静态属性也是属于对象
public class Student{
public void say(){
}
}
main:
Student s = new Student();
s.say;2、静态方法
用static关键字修饰的方法，调用静态方法可以使用类也可以使用对象，静态方法和静态属性都是属于类的，是这个类的所有对象共享的
public class Student{
public void say(){
}
}
main:
//调用方法1
Student s = new Student();
s.say;
//调用方法2（更加推荐）
Student.say();3、类中方法之间的调用
假设一个类中有两个方法，a和b（非静态）
public void a(){
b();
//this.b();
}
public void b(){
}
//注意：交互调用，会导致死循环
public void a(){
b();
}
public void b(){
a();
}假设一个类中有两个方法，a和b（静态）,假设a,b都在Student中
public static void a(){
b();
//Student.b();
}
public static void b(){
}假设一个类中有两个方法，a（静态）和b（非静态）
public static void a(){
//编译失败
//静态方法不能调用非静态方法，需要使用对象来调用
b();
}
public void b(){
}假设一个类中有两个方法，a（非静态）和b（静态）
public void a(){
//编译通过
//非静态方法能调用类中其他非静态方法
b();
}
public static void b(){
}4、方法的递归调用
一个方法在内部代码中自己调用自己
public void test(){
//不可取，一定要有退出条件
test();
}使用递归完成1加到100
public int f(int x){
if(x==1){
return 1;
}
return x+f(x-1);
} 
参数传递
形参是一个变量要接受形参的值
//形参
public void test(int a){
//...
}
main：
Test t = new Test();
t.test(1);//实参形参是一个变量，将来需要接收实参的值。本质上还是一个=号赋值操作，相当于把=号右边实参的值，赋给=号左边表示形参的变量，但是这个=号赋值的过程我们是看不见的。这个是JVM在运行的时候，调用方法的同时自动帮我们实现的。
当形参是一个引用类型变量的时候，那么将来的实参肯定是一个对象，然后把这个对象的内存地址值传给形参变量，这种情况称之为引用传递。
引用传递传的是内存地址值。
下午
参数传递（案例）
this关键字
1、区分局部变量和成员变量
public class Student{
private String name;
public void printName(String name){
//就近原则，那个变量离代码近，这个name是局部变量name
System.out.print(name);
//变量前加this.表示属性name（属性/实例/成员变量）
System.out.print(this.name);
}
public void setName(String name){
this.name = name;
//将局部变量name赋值给属性name
}
public void test(){
this.setName("tom");
//调用setName（）方法，this.可以不写
}
}public class Person{
public void say(){
//Person
}
}
public class Student extends Person{
public void say(){
//Student
}
public void test(){
say();//就近原则等价于this.say()
this.say();//Studnet
super.say();//Person
}
}public class Person{
public void say(){
//Person
}
}
public class Student extends Person{
public void test(){
say();//person
this.say();//Person
}
}2、使用this可以调用类中的构造器
this();//调用无参构造器
this("tom");//调用有参构造器注意，只能在类中的一个构造器里面，使用this的这种特殊语法来调用类中其他参数的构造器。普通的方法中，是不能够使用this来调用类中的构造器。
要求：
1、必须在构造器中使用this语法
2、必须是构造器中的第一句代码（只有this调用构造器的时候）
3、不能出现构造器自己的递归调用
3、this关键字的意义
在编写类中的过程，代码中使用了this，这个this表示当前类创建出的对象，并且使用对象调用了this所在的方法。
总结：this代表当前类对象
对象中方法的调用
1.我（类A）作为一个对象，去调用另一个对象（类B）的方法 2.别的对象（类B），调用我这个对象（类A）中的方法 3.我作为一个对象，自己调用自己的方法（this）
public class A{
public void test(){
B b = new B();
b.run();
}
public void say(){}
}
main: A a = new A();
a.test(); //A-调用->B
this.say();//A-调用->A
public class B{
public void run(){}
public void test(){
A a = new A();
a.say();
}
}
main: B b = new B();
b.test();//B-调用->A通过this比较两个对象的属性值
Student.java
public class Student{
private int age;
public Student(){}
public Student(int age){
this.age = age;
}
//s2当作参数传给test3
//o表示传过来的s2
//用this来表示s1对象
public boolean test3(Student o){
return this.age == o.age;
}
}
StudentTest.java
main:
Student s1 = new Student(30);
Student s2 = new Student(30);
//比较s1 s2的年龄
boolean f = s1.test3(s2);
System.out.println(f); //true
main:
Student s1 = new Student(30);
Student s2 = new Student(20);
//比较s1 s2的年龄
boolean f = s1.test3(s2);
System.out.println(f); //false
