Java基础整理

1.构造方法默认可以为空

在main方法里可以默认创建一个对象,虽然没有构造方法,但是默认会有一个空的构造方法,如下所示:

public class Test {
    
    public static void main(String[] args) {
        Test t = new Test();
    }

}

2.创建构造方法

创建构造方法之后,main方法调用时,要按照构造方法的格式调用,否则会报错

public class Test {
    String name;  //实例变量,对象变量
    
    //构造方法
    public Test(String name) {
        this.name = name;
    }
    
    public static void main(String[] args) {
        Test t = new Test("张三丰");
        System.out.println(t.name);
    }

}

3.多个构造方法

可以写入多个构造方法,main方法调用的时候,根据传参的不同,调用不同的构造方法

public class Test {
    String name;  //实例变量,对象变量
    int age;
    
    //构造方法
    public Test(String name) {
        this.name = name;
    }
    
    public Test(String name,int age) {
        this.name = name;
        this.age = age;
    }
    
    public static void main(String[] args) {
        //创建第一个构造方法的实例并调用
        Test t = new Test("张三丰");
        System.out.println(t.name);
        //创建第二个构造方法的实例并调用
        Test t1 = new Test("梅超风",18);
        System.out.println(t1.age);
    }

}

4.实例方法

实例方法是没有static关键字的,在main方法中直接使用创建的构造方法的实例调用实例方法即可

public class Test {
    String name;  //实例变量,对象变量
    int age;
    
    //构造方法
    public Test(String name) {
        this.name = name;
    }
    
    public Test(String name,int age) {
        this.name = name;
        this.age = age;
    }
    
    //实例方法  没有static关键字,需要在main方法创建构造方法的实例来调用
    public void add(int a,int b) {
        System.out.println(a+b);
    }
    
    public static void main(String[] args) {
        //创建第一个构造方法的实例并调用
        Test t = new Test("张三丰");
        System.out.println(t.name);
        //创建第二个构造方法的实例并调用
        Test t1 = new Test("梅超风",18);
        System.out.println(t1.age);
        //直接使用t1或者t2调用实例方法
        t.add(1, 2);
    }

}

5.重载

在同一个类中,方法名称相同,方法参数类型或者个数不同,我们把这种形式叫做重载

    //实例方法  没有static关键字
    public void add(int a,int b) {
        System.out.println(a+b);
    }
    //在同一个类中,方法名称相同,方法参数类型或者个数不同,我们把这种形式叫做重载
    public double add(double a,double b) {
        double sum = a+b;
        return sum;
    }
    
    public static void main(String[] args) {
        //创建第一个构造方法的实例并调用
        Test t = new Test("张三丰");
        System.out.println(t.name);
        //创建第二个构造方法的实例并调用
        Test t1 = new Test("梅超风",18);
        System.out.println(t1.age);
        //直接使用t1或者t2调用实例方法
        t.add(1, 2);
        //使用t1或者t2直接调用第二个实例方法
        System.out.println(t1.add(10.22, 10.33));
    }

6.类方法

使用static关键字的方法,是类方法,调用时可以不用实例化对象,直接使用类调用

    //类方法,使用static关键字,调用时可以不用实例化对象,直接使用类调用
    public static void sub(int a,int b) {
        System.out.println(a-b);
    }
    
    public static void main(String[] args) {
        //创建第一个构造方法的实例并调用
        Test t = new Test("张三丰");
        System.out.println(t.name);
        //创建第二个构造方法的实例并调用
        Test t1 = new Test("梅超风",18);
        System.out.println(t1.age);
        //直接使用t1或者t2调用实例方法
        t.add(1, 2);
        //使用t1或者t2直接调用第二个实例方法
        System.out.println(t1.add(10.22, 10.33));
        //类方法直接使用类调用,不用实例化对象
        Test.sub(10, 30);
    }

7.静态变量

static修饰,可以直接使用类调用

        static String sex;  //静态变量,可以直接使用类调用
    public static void main(String[] args) {
        //创建第一个构造方法的实例并调用
        Test t = new Test("张三丰");
        System.out.println(t.name);
        //创建第二个构造方法的实例并调用
        Test t1 = new Test("梅超风",18);
        System.out.println(t1.age);
        //直接使用t1或者t2调用实例方法
        t.add(1, 2);
        //使用t1或者t2直接调用第二个实例方法
        System.out.println(t1.add(10.22, 10.33));
        //类方法直接使用类调用,不用实例化对象
        Test.sub(10, 30);
        //静态变量可以直接使用类调用
        Test.sex="男";
        System.out.println(Test.sex);
    }

8.继承

当调用的方法都相似的情况下,可以归到一类,作为父类,比如cat和mouse都属于animal,那么animal就属于一个父类,cat和mouse就属于子类,这样子类就可以继承父类
Animal类如下:

    public class Animal {
    private String name;
    private int id;
    
    //构造方法
    public Animal(String name,int id) {
        this.name = name;
        this.id = id;
    }
    
    //实例方法
    public void eat() {
        System.out.println(name+"正在吃");
    }   
    public void sleep() {
        System.out.println(name+"正在呼呼睡大觉");
    }
    public void introduction() {
        System.out.println("大家好!我是 "+id+"号"+name+".");
    }
    

}

Cat类如下.直接继承父类:

public class Cat extends Animal{

    public Cat(String name, int id) {
        super(name, id);
        // TODO Auto-generated constructor stub
    }
    
    public static void main(String[] args) {
        Cat c = new Cat("小花猫",1200);
        c.eat();
        c.sleep();
        c.introduction();
    }
}

9.重写

继承的时候,如果想要写一个方法,实现方式不同,但是和父类方法名称相同,这种形式我们叫做方法的重写

public class Cat extends Animal{

    public Cat(String name, int id) {
        super(name, id);
        // TODO Auto-generated constructor stub
    }
    //和父类方法名称相同,但是实现不同,这种形式我们叫做方法的重写
    public void eat() {
        System.out.println(this.name+"正在吃大米");
    }   
    public static void main(String[] args) {
        Cat c = new Cat("小花猫",1200);
        c.eat();
        c.sleep();
        c.introduction();
    }
}

10.多重继承

Cat1可以直接继承Cat,也可以间接继承Animal

public class Cat1 extends Cat{

    public Cat1(String name, int id) {
        super(name, id);
        // TODO Auto-generated constructor stub
    }
    
    public static void main(String[] args) {
        Cat1 c1 = new Cat1("小黑猫",1006);
        c1.eat();
    }
    
}