Java基础(类与对象)

目录

简述

类的继承

继承本质

如何继承

相关问题

方法的重写和重载

java的修饰符

方法

普通方法

构造器/构造函数/构造方法

方法的重载

方法的重写

类的加载顺序

---

简述

类是构建对象的模板，一个类可以创建多个对象，每个对象的属性的最初来源是其所在的类规定的默认属性。

类可以看作是所有对象的模板，是一个抽象的概念，对象是类的具体化的实体，是实际的个体。

Student s=new Student();//创建Student类的对象，对象名称叫s

Student:是一个数据类型，规定了数据在内存当中的存储形式。

S:是项目名或者变量名。

new关键字:要求在堆内存中开辟新的内存空间。

Student()构造器:在创建对象时，给对象赋值。

=赋值操作:是将堆内存中创建好的内存空间的地址赋给s变量。

类的继承

继承本质

继承的本质就是代码的复用，子类可以使用父类已经写好的代码，子类就不需要重新写代码了。

子类可以调用父类的方法、变量，也可以调用自己的方法、变量。父类不能调、用自己子类的方法、代码。

如何继承

子类 extends 父类名

public  class  Person{
    public Double height;
    public String name;
    public  char sex;
    public  void  run(){
        System.out.println("输出");
    }
    public  void  a(){
        System.out.println("-----");
    }
}

public  class  Student{
   public void study(){
       System.out.println("111")
   } 
}

public static void main(String[] args) {
//person是父类，student是子类
Student student=new Student();
student.run();
student.a();
student.study();//调用自己的
student.height=180.0;

Person person=new Person();
person.study();//调用不了子类student独有的study函数
    }

相关问题

java的继承层次当中是不能互相继承的。

一个类可以被多个类当父类，一个子类只能用一个父类(java仅支持单继承)。

方法的重写和重载

java的修饰符

public共有的 在本类可以访问 子类可以访问 同包可以访问 不同包可以访问。

private私有的 在本类可以访问 子类不可访问 同包不可访问 不同包不可访问。

protected受保护 在本类可以访问 子类可以访问 同包可以访问 不同包不可以访问。

不写默认 在本类可以访问 子类可以访问 同胞可以访问 不同包无法访问。

public修饰的代码其他类都是可以访问的，private修饰的代码除了本类都不能进行访问。

方法

除了main方法能自动入栈以外，其他的方法不能自动入栈，一个方法要想调用(除了main)必须有其他的方法调用才能入栈启动。

普通方法

1、方法是有访问权限的。

2、方法必须写上返回数据的类型，而且return返回的必须是该类型。如果不需要返回数据就写void，在代码中写一个return就行。

void int study(){
       System.out.println("111");
    return 18;
   }

3、在同一个类当中，方法可以相同，但是方法的签名不能相同(方法的签名=方法名+参数列表的类型)。

void study(int name){
       System.out.println("111");
   }
   void study(String name){
       System.out.println("222");
   }

4、方法上可以使用其他关键字进行修饰，比如static和final，它们有不同的意义。

构造器/构造函数/构造方法

作用：在创建对象时给对象赋初值的。

特点：

1、在类当中构造函数必须和类名相同。

2、在类当中有一个默认的不显示的无参数的构造器，一旦写了新的构造器，那个无参数的构造器就会被覆盖掉。

3、构造函数不需要写返回类型，构造函数是没有返回值的。

4、一个类当中可以有一个或者多个构造函数。

public class A {
    private String name;
    private int age;
    public A(String name) {
        this.name = name;
    }
    public A(String name,int age){
        this.name=name;
        this.age=age;
    }
}

方法的重载

在一个类当中方法名相同但是参数列表不同就是方法的重载。

public class A {
    private String name;
    private int age;
    public A(String name) {
        this.name = name;
    }
    public A(String name,int age){
        this.name=name;
        this.age=age;
    }
}

方法的重写

方法的重写一定在父子类当中的，子类重新实现父类方法的功能。

继承的本质是代码的复用，在复用的过程中，当父类的方法不一定完全适用于子类，这时候子类就需要子类对父类的方法进行重写。

public class A{
    public void run(){
        System.out.println("A跑得很快")
    }
}

public class B extend A{
    public void run(){
        System.out.println("B跑得很快")
    }
}

public class Main {
    public static void main(String[] args) {
        B b=new B();
        b.run();
    }

输出:B跑得很快

类的加载顺序

static修饰的代码块，在main方法执行之前执行，其目的是修饰main方法

程序执行的第一步是main方法入栈，static修饰的代码块会在main入栈之前执行。

即使不创建父类对象，创建子类对象时，执行流程是先创建父类对象，再创建子类对象。

编译之前先进行扫描，优先扫描带有main方法的类，如果发现这个类有父类，停下扫描此类，优先扫描父类，直到扫描一个没有父类的类为止。

然后执行编译，编译后，父类先进入方法区，一旦一个类进入方法区，其中的static修饰的代码块会立刻执行，然后是子类进入方法区，然后执行子类的static代码块。

然后就是main方法入栈，此代码过程中，main方法中创造了一个子类的对象，子类对象的创建必须需要父类对象先创建，所以计算机默认先创建父类对象，此时输出父类中的方法，然后子类对象创建完毕，输出子类中的方法。

到此，文章结束。