类和对象 继承 重写 重载 java代码生成顺序

类和对象

1. 类      : 是一个模板，它描述一类对象的行为和状态
2. 对象  : 是类的一个实例,有状态和行为
3. 面向对象的三大特征
4. 封装,继承,多态

　　

　　构造函数　　:对对象中的属性初始化操作,或者是准备资源

1. 系统会自动给每一个类添加一个无参构造方法
2. 如果自定义了构造方法,系统默认构造犯法就不存在了

 

　　static

1. 一个类中静态方法不能直接调用非静态方法
2. 因为java中类对象先被加载,这时对象还未被加载

 

 

• 继承

1. 子类继承父类,子类就拥有父类中定义的可继承的属性和方法
2. 子类继承父类,单继承(只能有一个父亲)
3. 可以多重继承(爷孙)

 

1. 在子类的构造方法中
2. 第一行代码默认调用父类的无参构造方法
3. super()必须放在第一行
4. 假如父类没有无参的构造方法,就会报错

• 方法重写

1. 子类重写父类的方法
2. 方法名不变
3. 参数列表必须保持不变
4. 子类中重写的方法的访问权限可以更高(开放),不能更低(闭塞)

• 方法重载

1. 方法名一样,参数列表不一样

结构:

 

 

• Obj1.java

 

 

    public static void main(String[] args) {
        
        Person person = new Person();
        person.setName("zhangsan");
        person.setAge(22);
        person.setSex("male");
        System.out.println(person.getName());
        person.speak();
    }

 

• Obj2.java

    public static void main(String[] args) {
        Son son = new Son();
        son.name = "zhangsan";
        son.code();
        Partent partent = new Son();
        //Son s = (Son)new Partent();
        //Son s = (Son)partent;
        partent.code();
    }

• Partent.java

public class Partent extends Person{
    
    public Partent() {
        // TODO Auto-generated constructor stub
        System.out.println("调用Partent的构造方法");
    }
    
    public void code() {
        System.out.println("I am coding");
    }
}

• Person.java

package com.obj;

public class Person {
    String name;
    private int age;
    private String sex;
    
    public Person() {
        this.name = "wangwu";
        this.age = 22;
        this.sex = "male";
    }
    
    public Person(String name , int age , String sex) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    public void speak() {
        System.out.println(name + " speak");
    }
    public String getName() {
        return this.name;
    }
    public int getAge() {
        return age;
    }
    public String getSex() {
        return sex;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
}

• Son.java

package com.obj;

public class Son extends Partent{
    //子类继承父类,子类就拥有父类中定义的
    //可继承的属性和方法
    //子类继承父类,单继承(只能有一个父亲)
    //可以多重继承(爷孙)
    
    public Son() {
        super();
        //在子类的构造方法中
        //第一行代码默认调用父类的无参构造方法
        //super()必须放在第一行
        //假如父类没有无参的构造方法,就会报错
        System.out.println("调用Son的构造方法");
    }
    
    public void play() {
        System.out.println("I am playing...");
    }
    
    //方法重写
    //子类重写父类的方法
    //方法名不变
    //参数列表必须保持不变
    //子类中重写的方法的访问权限可以更高(开放),不能更低(闭塞)
    public void code() {
        System.out.println("I want to earn money");
    }
    
    
    //方法重载
    //方法名一样,参数列表不一样
    public void code(String code) {
        System.out.println("I am print "+code);
    }
    public void code(String code , int a) {
        System.out.println("I am print "+code);
    }
    public int code(int code) {
        System.out.println("I am print "+code);
        return 0;
    }
}

 

• java代码生成顺序

1. 先加载静态代码
2. 先加载父类再加载子类
3. 代码块 > 构造

结构:

 

 

• O.java

 

 

package com.obj1;

public class O {
    public static void main(String[] args) {
        S s = new S();
        S ss = new S();
        //打印结果是:
        //1->4->2->3->5->6(->2->3->5->6)
        //1---执行父类静态代码块
        //2---执行子类静态代码块
        //3---父类的普通代码块
        //4---父类的构造
        //5---子类的普通代码块
        //6---子类的构造
        //*******************//
        //7---父类普通代码块
        //8---父类的构造
        //9---子类普通代码
        //10--子类构造
        //总结:
        //1先加载静态代码
        //2先加载父类再加载子类
        //3代码块 > 构造
    }
}

 

 

 

•  P.java

package com.obj1;

public class P {
    static {
        System.out.println("1---父类静态代码块---1");
    }
    public P(){
        System.out.println("3---父类构造----3");
    }
    {
        System.out.println("2---父类普通代码----2");
    }
    
}

• S.java

package com.obj1;

public class S extends P{
    static {
        System.out.println("4---子类静态代码----4");
    }
    {
        System.out.println("5---子类普通代码块----5");
    }
    public S(){
        System.out.println("6---子类构造----6");
    }
}