java中的方法，类，访问修饰符

1.方法的定义

• 定义方法的五个要素：修饰词，返回值类型，方法名，参数列表，方法体

public static void main(String[] args){
    System.out.println("方法体");
}

• return语句可以将数据返回给方法的调用。return后面直接加分号，表示结束方法。

---

2.方法的重载

• 方法的签名：方法名和参数列表
• 一个类中，不能有两个方法的签名完全相同，即一个类中不能有两个方法的方法名和参数列表都相同。方法名相同而参数列表不相同是可以的

public class Person {
    //下面的两个方法会出现编译错误
    public void fun(String str){....};
    public void fun(String str){....};    
}

• 在java语言中，一个类中允许多个方法的方法名称相同，但参数列表不同，称为方法的重载。可以理解为多个不同的方法，只是方法名恰好相同
• 参数列表不同：具体指参数的类型或顺序或个数不同。重载和修饰符，返回值，是否抛异常都无关

public class Person {
    //下面的两个方法即是重载。调用时，根据传入参数的类型，
    调用相应的方法
    public void fun(String str){....};
    public void fun(int age){....};    
}

---

3.构造方法

• 构造方法不同于其他方法，名称必须和类名相同，没有返回值，也不能写void

public class Person {
   //构造方法，修饰符可以任意，一般为公有
   public Person(String age){
      this.age = age;
   }
}

• this关键字使用在方法体中，表示调用该方法的当前对象。在没有歧义的情况下可以省略this。如上面的构造方法，必须加this，用来区分局部变量和成员变量
• 默认的构造方法：每个类都必须有构造方法，如果类中没有定义构造方法，编译器会在编译时添加一个无参构造方法。如果已经定义了构造方法，java编译器不会再添加默认的构造方法

public class Person {
   private String name;
   private String age;
   //没有定义构造方法，会默认添加一个无参构造方法
}

• 构造方法的重载：为了使用方便，可以对一个类定义多个构造方法。这些构造方法名称相同，参数列表不同。称为构造方法的重载
• 继承中的构造方法：构造方法不能继承。子类的构造方法中必须通过super关键字调用父类的构造方法。如果子类中没有调用，java编译器会自动添加对父类无参构造方法的调用。(如果父类没有无参构造方法，编译会报错)

public Student class extends Person {
    public Student(){
        super();//编译器自动加入，
                //super()必须位于子类构造方法的第一行
    }
}

---

4.类中定义成员变量后，如果没有赋值，会有默认值。

• byte,short,int,long,为0;float,double为0.0;boolean为false,引用类型为null
• 除了8种基本类型之外，用类，接口，数组声明的变量都称为引用类型变量，简称引用

class Person {
    private int age;
    private String name;
}
Person s = new Person();

---

5.继承

• 通过extends关键字实现类的继承，子类继承了父类的成员变量和方法（不包括私有的），也可以定义自己的成员变量和方法。java不支持多继承，一个类只能有一个父类。
• 父类的引用可以指向子类的对象，这样称为向上造型。父类的引用只能访问属于自己的属性和方法，子类扩展的无法访问。(这里的父类指超类，父亲类，爷爷类.....)

public class Person {
    public String name;
    public Integer age; 
}

public class Teacher extends Person {
    public String course;

    public static void main(String[] args) {
        Person p = new Teacher();
        p.name = "mary";
        p.age = 14;
        p.course = "math";//编译会报错，因为这个course属性为子类独有的，父类不能访问。
    }
}

• 子类继承了父类的方法，子类可以重新定义方法的逻辑，称为重写。即方法名和参数列表和父类相同，实现逻辑不相同。
• 当子类重写的方法被调用时，(引用指向的都是子类的对象)无论是父类的引用，还是子类的引用，运行的都是子类重写后的版本。
• 子类在重写父类方法时，通过super关键字调用父类版本

public class Person {                           
    public String name;                         
    public Integer age;                         
                                              
    public void fun(){                          
        System.out.println("I am a father");    
    }                                           
}       

public class Teacher extends Person {
    public String course;

    @Override
    public void fun() {
        super.fun();
        System.out.println("I am a son");
    }

    public static void main(String[] args) {
        Person p = new Person();
        p.fun();// I am a father
        
        Person pt = new Teacher();
        pt.fun();//I am a father I am a son
        Teacher t = new Teacher();
        t.fun();//I am a father I am a son
    }
}

• 重写和重载的区别

--重载是指一个类中定义了多个方法名相同，但参数列表不同的方法。编译时会根据参数的个数和类型，顺序绑定相应的方法。
--重载只和方法签名相关
--重写是指子类中定义和父类完全相同的方法，在程序运行时根据对象类型不同调用不同的版本(非引用类型)
--重写遵循两同两小一大原则，方法名和参数列表必须相同，返回值类型和抛出和异常小于等于父类，访问权限大于等于父类

---

访问修饰符

• 对于普通类的修饰只能用public和默认方式，protected和private可以修饰内部类
• 成员变量和方法可以用四种修饰符

修饰符	本类	同一个包中的类	子类	其他类
public	可以	可以	可以	可以
protected	可以	可以	可以	不可以
default(默认)	可以	可以	不可以	不可以
private	可以	不可以	不可以	不可以