1、方法的重载（overload）

　　同一个类中同时存在一个以上的同名函数，参数个数或类型不同或顺序不同，称为方法的重载。

和返回值无关！

　　构造器重载：非默认构造器和默认构造器其实就是方法的重载。

 

2、this:这个，指对象，真实存在的。　　类——>实例化——>对象

　　this的三种用法：

　　　　1、在类本身的方法中或构造器中引用该类的实例变量和方法;



public A(){
        this.name="Mike";
        this.ok() ;
    }



 

　　　　 2、将当前对象作为形参或返回值传递给其他方法或构造器   return this；（返回自己，可以始终使用自己本身对象（对象的属性值不会随返回new成初始值）进行调用）　　　



public String getName() {
        return this.name;



(只能在构造器的第一条使用，写在其他地方不好使） 用来改变使用构造器的顺序。



public A(){
        this(100);
    }
    public A(int age){
        this.age=age;
    }



 

　　链式构造器：



public Person1(){
            System.out.println("构造器Person1()被调用");
            sex ="Male";
            age=20;
            name="mike";
            System.out.println("name="+name+" age="+age+" sex="+sex);
        }
        public Person1(String theName){
            //调用本身的默认构造器Person()
            this();//this用来调用默认的构造器
            System.out.println("构造器Person1(String theName)被调用");
            name = theName;
            System.out.println("name="+name+" age="+age+" sex="+sex);
        }
        public Person1(String theName,int theAge){
            //调用本身的非默认的构造器Person(String theName)
            this(theName);
            System.out.println("构造器Person1(String theName,int theAge)被调用");
            age = theAge;
            System.out.println("name="+name+" age="+age+" sex="+sex);
        }
public static void main(String []args){
Person1 person=new Person1("asd",18);
}


 

3、super:对象　　类——>实例化——>对象：指父类对象。

　　两种用法：

　　　　1、用于访问父类中定义的属性，成员方法（当重写父类方法后，想调用父类方法，必须使用super，因为重写后的方法把父类的方法掩盖了）

　　　　



public class C extends C0{
    public void bark(){
        super.go();
    }
    public void go(){
        System.out.println("C-go");
    }

    public static void main(String[] args) {
        new C().bark();
    }
}
class C0{
    public void go(){
        System.out.println("C0-go");
    }
}



 

　　　2、　用于在子类构造器中调用父类的构造器。（也必须是第一句且放在构造器中）

super的追溯不仅限于直接父类：即不能够使用super.super.方法()的用法来调用爷爷类中的方法，可以在父类中新创建一个方法用来调用爷爷类中的方法，或者破坏父类方法，让其中的同名方法跳到爷爷那儿。



public class D extends D0{
    public static void main(String[] args) {
 //       new D().go();
           new D().to();
    }
    void go(){
        System.out.println("go");
    }
}
class D0 extends D00{
    void to(){
        super.go();
    }
    void go(){
        //super.go();
        System.out.println("0-go");
    }
}
class D00{
    void go(){
        System.out.println("00-go");
    }



 

4、动态初始化块block{}

　　位置：类的里面，与构造器、方法、属性同地位

　　　　　运行顺序：初始化块先执行——>然后执行构造器

　　特点：先于构造器执行，必须实例化才能执行。

 

5、覆盖（override）：重写

　　子类中的方法必须和父类中的方法名字，参数类型，返回值完全相同时，才可以重写。

　　子类的权限不能比父类权限更严格。（父类不能为私有的）

　　静态不能重写。

6、权限：

　　

private:私有的:仅能在自己的类中进行调用。
[default]:默认：当子类继承父类，实例化子类的时候，跨包不能使用
protected：保护的：当子类继承父类，实例化子类的时候，跨包能使用
public：公共的：可以在任何包中 任何类中进行调用

 

7、toString（）方法

　　正常的toString方法返回的是没用的栈地址

　　一般我们对其进行重写：因为他是Object下的方法，所有类的所有对象都可以调用toString方法，这样我们输出对象时返回的就是toString方法中的输出内容，而不是一个地址了。