Java中的类(基础详解)

文章目录

  • 可以有多个类,但只能有一个public类
  • 类 = 字段+方法
  • 类的构造函数
      • 我们没写构造函数的时候
      • 如果我们自己写了构造函数
      • 构造函数中 this 的使用
  • 类的修饰符 / 控制符
      • 第一类:==访问修饰符==
      • 第二类:==其他修饰符 / 非访问控制符==
          • static字段
          • final
          • abstract

java中最常见的就是类,可以说,Java程序是由一个一个的类组成的

在C++中,我们只有在面向对象编程的时候才会用到类,一般想实现某一个功能可以写一个函数。

可以有多个类,但只能有一个public类

在一个 .java 程序中,可以出现多个类,但有且仅有一个类是 public 并且这个public类的名字必须和文件名相同,看图片来的快,有图有真相

Java中的类(基础详解)_第1张图片

我们看到此时主类的名字和文件名相同,此时没有报错,如果我改一下主类的名字,情况如下

Java中的类(基础详解)_第2张图片

很明显的报错,下面我们来看看错误原因

在这里插入图片描述

翻译过来就是:hello 类是public的,应该被声明在一个文件名叫 hello.java 的文件中。

下面我们来看一下一个java中有多个类型情况:

Java中的类(基础详解)_第3张图片

这里就是记住java中可以有多个类,但是只能有一个public类。

因为每一个java程序运行的时候都会先执行public这个类,而且只执行public类中的代码,如果写了其他的类但是在public类中没有用到,就不会执行其他的类,但是这个类的写法必须正确;如果写了其他的类并在public类中使用了其他的类,那么也会执行其他类的相应代码。

而且除public类之外的其他类也可以写在public类的后面,即使在主类中要调用这个类

Java中的类(基础详解)_第4张图片

代码:

public class Main {
    public static void main(String args[]) {
        System.out.println("hello world!");
        person p=new person();  //创建一个person类
        p.sayhello();  //调用类其中的一个方法
    }
}
class person{
    String name;
    int age;
    void sayhello(){
        System.out.println("嗨嘿嗨");
    }
    void printages(){
        System.out.println(age);
    }
}

我们可以看到在程序截图中可以看到有 1 usage 或者 2 usages ,但是在单纯的代码片段中没有。

这个单词 usage 的意思是 用法,惯例
也可以认为是 仓库中本Jar被其他Jar依赖引用的次数

其实就是某个变量或者函数被使用的次数,这个其实不用管它,影响不大。

类 = 字段+方法

我们举一个类的例子:

class person{
    //name和age属于类中的字段
    String name;
    int age;
    //sayhello()函数属于类的方法
    void sayhello(){
        System.out.println("嗨嘿嗨");
    }
}
  • 字段 是类的属性,是用 变量来表示的。
    我们可以认为类中的变量都属于类的字段,字段有成为 域,域变量,属性,成员变量等
  • 方法 是类的操作和功能,是用函数来表示的。

类的构造函数

类的构造函数可以用来给一个类的数值赋一个初值,用来初始化(new)该类的一个新的对象。

而且构造函数和类名同名,并且不需要写返回值类型

class person{
    String name;
    int age;
    person(String s,int a){  //类的构造函数
        name=s;
        age=a;
    }
    void sayhello(){
        System.out.println("嗨嘿嗨");
    }
    void printages(){
        System.out.println(age);
    }
}

我们没写构造函数的时候

如果我们自己没有写构造函数,那么程序会自动生成一个默认构造函数,这个默认构造函数没有参数,函数中也没有任何语句,也就是相当于什么都不做。
默认生成的类似于这样

person(){}

其实就是什么都没做。

在没写构造函数的时候,初始化一个新对象的时候,不需要写参数
Java中的类(基础详解)_第5张图片
运行结果
Java中的类(基础详解)_第6张图片

如果我们自己写了构造函数

那么程序就不会再生成默认构造函数了,在初始化一个对象的时候,就使用咱们自己写的构造函数了,并且如果自己写的构造函数中有参数,必须要加上参数,否则报错,如果本身就没写参数,那么可以不写。

还是看图片来的快

Java中的类(基础详解)_第7张图片

构造函数中 this 的使用

  1. this 指当前这个对象实例本身

比如说,age=和 this.age 是一样的,都是可以运行的。

void printages(){
        System.out.println(age);
}
void printages(){
        System.out.println(this.age);
}
  1. this 还可以用来解决 局部变量 同名的问题,比如说

这样写也是可以运行的,那么this.name指的就是域变量,name指的就是参数变量。

Java中的类(基础详解)_第8张图片

person(String name,int age){
        this.name=name;
        this.age=age;
}
  1. 在构造函数中,this 可以调用另一种构造方法,并且这条调用语句必须放在第一句
person(){
	this()
	...
}

类的修饰符 / 控制符

作用:可以修饰类,也可以修饰类中的成员(字段,方法)

第一类:访问修饰符

public, private, protected,

  • private:只能在同一个类中被访问。
  • protected:可以在同一个类中,同一个包中,和不同包中的子类中被访问。
  • public:public的访问范围最广,一般都可以访问。
  • 如果不加修饰符,则只能在同一个类和同一个包中,这2中情况下访问。

类的访问控制符为public或者默认。
如果类用public修饰,则该类可以被其他类所访问。
如果类是默认访问控制符,则改类只能被同包中的类访问。

第二类:其他修饰符 / 非访问控制符

abstract, static, final

  • static:静态的,非实例的,类的
    可以修饰内部类,也可以修饰成员
  • final:最终的,不可改变的
    可以修饰 成员局部变量
  • abstract:抽象的,不可实例化的
    可以修饰 成员
static字段
  • 静态字段最本质的特点是:它们是类的字段,不属于任何一个对象实例
  • 它不保存在某个对象实例的内存区间中,而是保存再类的内存区域的公共存储单元。
  • 类中的static变量可以通过了类名直接访问,也可以通过对象实例来访问,两种方法的结果是相同的
    因为这个static变量是存在最原本的类中的,它本身和用它来实例化的对象都可以访问。
    例如System类的in和out对象,就是属于类的域,直接用类名来访问,即System.in和System.out 。
    再举一个下面的例子:
import java.io.*;

public class Main {
    public static void main(String args[]) {
        person p=new person("ycy",16);  //创建一个person类
        System.out.println(p.age);  //这里用一个实例化的对象来访问类中static字段
        System.out.println(person.age); //这里可以用类名来直接访问类中static字段
    }
}
class person{
    String name;
    static int age;
    person(String name,int age){
        this.name=name;
        this.age=age;
    }
}

输出结果:

Java中的类(基础详解)_第9张图片

final
  • final类:如果一个类被final修饰符所修饰和限定,说明这个类不能被继承,即不会拥有子类
  • final方法:final修饰符所修饰的方法,是不能被子类所覆盖的方法。
  • final字段和final局部变量:它们的值一旦给定,就不能更改。并且它们是只读量,它们能且只能被赋值一次,不能多次赋值。
  • 如果一个字段被 static final 同时修饰时,它可以表示常量。如果不给定初始值,则按默认值进行初始化(数值为0,boolean类型为false,引用类型为null)
abstract
  • 凡是用abstract修饰符修饰的类被称为抽象类。
  • 抽象类不能被实例化。
  • 抽象类方法在子类中必须被实现,否则子类仍然是abstract的。

你可能感兴趣的:(Java,java,jvm,c++)