1. Toy模板网首页
  2. > Toy博客

Java基础——类和对象

9月前 作者：explorer363 分类：Toy博客 阅读(38) 违法举报

这篇具有很好参考价值的文章主要介绍了Java基础——类和对象。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

目录

一、类和对象的基本概念

二、类与对象的定义与使用

1.创建类的语法：

2. 创建具体的对象：

 3.范例（创建一个Person 类的对象）

 三、static关键字  

（一）static修饰属性（类属性、类变量）

（二）static修饰方法（类方法、工具方法）

（三）static修饰代码块（静态代码块）

（四）static修饰内部类（静态内部类）

四、面向对象的特性

 五、构造方法

六、this 关键字（表示当前对象的引用）

 七、代码块

一、类和对象的基本概念

在Java中一切皆对象，一切都围绕对象进行，找对象、建对象，用对象等

类：把具有相同属性和行为的一类对象抽象为类。类是抽象概念，如人类、犬类等，无法具体到每个实体。

对象：某个类的一个实体，当有了对象后，这些属性便有了属性值，行为也就有了相应的意义。

类是描述某一对象的统称，对象是这个类的一个实例而已。有类之后就能根据这个类来产生具体的对象。一类对象所具备的共同属性和行为（方法）都在类中定义。

二、类与对象的定义与使用

1.创建类的语法：

class 类名称 {

成员变量/ 实例变量；

成员方法；

}

2. 创建具体的对象：

类名称 引用名称 = new 类名称（）

Person per = new  Person();

  这个对象的引用   对象（在堆中储存）

（相当于给对象起了个名字）（所有类的对象都是引用数据类型）

 3.范例（创建一个Person 类的对象）

public class Test {
    public static void main(String[] args) {
        //创建一个实例化对象
        Person per1 = new Person();
        //通过对象来调用实例变量、成员方法
        per1.name = "小韩";
        per1.age = 18;
        per1.sex = "女";
        per1.print();
        Person per2 = new Person();
        per2.print();
    }
}
class Person{
    //成员变量（实例变量)，在堆中的每个对象中存储，通过对象调用
    String name;//默认值为null
    int age;//默认值为0
    String sex;//默认值为null
    //成员方法（实例方法），在JVM的方法区中存储，通过对象调用
    void eat(String food){
        System.out.println(name+"正在吃"+food);
    }
    void print(){
        System.out.println("name:"+name+", age:"+age+", sex:"+sex);
    }
}

输出结果：

java类和对象的基本概念,java

注意事项：

  1. 在Java中一个源文件（*.java）只可以存在一个主类（public class）
  2. 类的命名规则：使用有意义的大驼峰单词命名法，每个单词的首字母都要大写
  3. 类中定义的成员变量都有默认值
  4. 关于引用数据类型的特殊值 null:null在Java中表示“空引用”，即只有名字，没有任何对内存中的地址，如果直接使用值为null的引用，去操作（使用.操作符）任何属性或者方法（成员变量、成员方法），都会报错。  如：空指针异常

    //sex的默认值为null

    //sex.length()

    System.out.println(per2.sex.length());

         java类和对象的基本概念,java

 三、static关键字  

（一）static修饰属性（类属性、类变量）

1.当一个实例变量被static关键字修饰后，它就表示类的属性，该类的所有对象共享此属性，且对象的属性值相同。static修饰的属性在JVM的方法区中存储。

2.static修饰的属性，直接通过类名称就可以访问，无须通过对象。

public class staticTest {
    public static void main(String[] args) {
        Person per1 = new Person();
        Person per2 = new Person();
        per1.name = "小韩";
        per1.age = 18;
        per1.print();
        per2.print();
        Person.country="日本";
        per1.print();
        per2.print();
        System.out.println(Person.country);
    }
}
class Person {
    //实例变量，成员方法，必须通过该类的对象来访问
    String name;
    int age;
    String sex;
    //静态成员变量，不属于对象，属于类，保存在方法区中
    // 调用时通过 类名称.country来进行访问
    static String country = "中国";
    void print(){
        System.out.println("name:"+name+", age:"+age+", country:"+country);
    }
}

输出结果：

java类和对象的基本概念,java

注意： 

 Person per  = null;
       System.out.println(per.country);//相当于Person.country

 并不会报空指针异常：static属性称为类属性，通过类名称直接访问，此时没有对象也能调用（包含该类的null引用）

3.final 和 static 的区别

class Person {
final int age = 18;//成员常量，在堆中存储，必须在定义时就赋值
static String country = "中国"//静态变量，在方法区中存储，所有Person类的对象共享
}

 若在类中定义了一个常量，通常情况下都会把static 和 final 共同使用，称为类的常量

（因为age属于成员常量，Person类的所有对象都有age这个属性，且值都是18——>天然的共享概念，将它定义为static final，所有Person类的对象共享这个属性，全局唯一。（既节省空间，有对应共享语义）） 

全局常量的命名规则：所有单词全部大写，多个单词使用下划线分隔

static final String STUDENT_SCHOOL ="清华大学";

问题1：能否在方法中定义一个static变量？

不能。在方法中定义的变量是局部变量，在栈中存储，而 static变量是在方法区中存储，若要在方法中定义一个static变量就会产生矛盾，因为一个变量不可能既在栈中存储，又在方法区中存储。

 java类和对象的基本概念,java

（二）static修饰方法（类方法、工具方法）

static修饰的方法通过类名称直接访问方法，没有对象也可以访问。

问题2：为什么static 方法是一个静态方法？ 

因为主方法是程序的入口，在进入主方法前没有对象， 如果主方法是一个成员方法，需要通过对象调用，就会产生矛盾。要使程序开始执行，只有通过类名称直接调用静态方法，无须产生对象。 

问题3：静态方法能否访问成员变量和成员方法？

不能。 静态方法可以通过类名称直接访问，此类中没有对象也可以访问；成员方法和成员变量必须要通过类中的对象来访问。没有对象的方法去调用必须通过对象访问的变量和方法，二者之间矛盾。

java类和对象的基本概念,javajava类和对象的基本概念,java

 问题4：成员方法能否访问静态变量和静态方法？

可以。 必须通过对象访问的方法去调用不需要对象就可以访问的变量和方法，逻辑通过

static方法只能调用静态变量和静态方法等，static家族的成员可以相互调用（都属于静态域）

java类和对象的基本概念,java  

问题5：普通的类能否使用static关键字修饰（不是内部类）？

类定义出来是要产生对象的，用static关键字修饰一个类，这个类不需要对象就能调用，矛盾。 

java类和对象的基本概念,java

（三）static修饰代码块（静态代码块）

（四）static修饰内部类（静态内部类）

四、面向对象的特性

面向对象一共有三大特性：封装、继承和多态（本篇博客主要讨论封装性）

封装：保护性和易用性

封装有很多表现形式，private实现属性和方法的封装只是其中一种。

权限修饰符：在Java中，权限修饰符指的是所修饰的属性、方法或者类可见的范围有多大。

一共有四大访问修饰修饰符，可见的范围由小到大依次为 :

private（私有的）：被private 修饰的属性和方法，只在当前类可见，出了类的{ }，对外就完全隐藏了，外部不知道有其存在。

 default(不需要写这个关键字，什么权限也没有（包访问权限）)

protected（继承访问权限）

public（公共的、公开的）：被public 修饰的，在当前程序（项目）中都是可见并且可以使用的。

//公共访问权限，主类
public class privateTest {
    public static void main(String[] args) {
        Bank bank = new Bank();
        bank.setPassword();
        System.out.println("修改后的密码为：");
        System.out.println(bank.getPassword());
        System.out.print("银行卡号为：");
        System.out.println(bank.getCardNum());
        System.out.print("银行卡余额为：");
        System.out.println(bank.getBalance());
    }
}
//缺省修饰符，包访问权限
class Bank{
    //私有属性，只在Bank这个类内部可见
    private int cardNum;//卡号，只可取
    private double balance;//余额，只可取
    private String password = "123456";//密码，既可取也可改
//要在类的外部去使用这些私有属性，需要使用类提供的getter()和setter()方法
    //alt + insert 快速生成getter()和setter()方法
    //shift+A全选
    //get + 属性名称 = 方法命名
    public int getCardNum() {
        return cardNum;
    }

    public double getBalance() {
        return balance;
    }

    public String getPassword() {
        return password;
    }
//设置新密码
    public void setPassword() {
        //验证旧密码（安全性）
        Scanner scan = new Scanner(System.in);
        int count = 0;
        while(true){
            System.out.println("请输入您的旧密码:");
            String oldPass = scan.nextLine();
            count ++;
            if (oldPass.equals(password)) {
                System.out.println("验证成功，请输入您的新密码：");
                String newPass = scan.nextLine();
                password = newPass;
                System.out.println("密码修改成功");
                break;
            }else{
                System.out.println("密码错误，请查证后再试！");
                if(count == 3){
                    System.out.println("验证次数过多，银行卡已锁定");
                    break;
                }
            }
        }
    }
}

 java类和对象的基本概念,java

 问题6： private 关键字能否修饰一个类（外部类）？

不能。定义类是为了产生对象，让外部使用的。若用 private 关键字封装此类，则外部根本不知道此类的存在，更不用提使用对象了，矛盾。

java类和对象的基本概念,java

 五、构造方法

1、构造方法：构造方法是类中非常特殊的一类方法，使用关键字new 实例化对象时实际上调用的就是该类的构造方法。

2.构造方法的作用就是产生对象

3.使用new关键字产生一个对象时，大致分为以下两步：

（1）为对象在堆中分配空间（空间大小由该类中成员变量的属性决定）

 （2）调用对象的构造方法为对象成员变量赋值（当构造方法调用结束后，该对象初始化完成）

4.构造方法的语法规则

（1）方法名称与类名称完全相同

（2）构造方法没有返回值声明（不是void）

（3）一个类中至少存在一个构造方法，若没有显示定义，编译器会生成一个默认的无参构造。

public class Test {
    public static void main(String[] args) {
        //当创建一个对象时，默认调用该类的构造方法
        Person person = new Person();
    }
}
class Person{
    String name;
    int age;
    String sex;
    //构造方法名称与类名称完全相同
    //没有返回值声明
    public Person(){
        System.out.println("Person的构造方法");
    }
}

 输出结果：java类和对象的基本概念,java

 若没有定义构造方法，编译器会生成一个默认的无参构造

public class Test {
    public static void main(String[] args) {
        //当构造对象时，默认调用该类的构造方法
        Person person = new Person();
    }
}
class Person{
    String name;
    int age;
    String sex;
}

java类和对象的基本概念,java

 5.当类中自定义了构造方法，默认的无参构造就不再生成。

public class Test {
    public static void main(String[] args) {
        //当构造对象时，默认调用该类的构造方法
        Person person = new Person();
    }
}
class Person{
    String name;
    int age;
    String sex;
    public Person(String n){
        name = n ;
        System.out.println("Person类的有参构造");
    }
}

 编译出错：

java类和对象的基本概念,java

 6、构造方法的重载

 构造方法是为了类中的成员变量赋值的，此时的重载只可能是参数的个数不同。

public class Test {
    public static void main(String[] args) {
        //当构造对象时，默认调用该类的构造方法
        Person person = new Person();
        Person person1 = new Person("小韩");
        Person person2 = new Person("小韩",18);
        Person person3 = new Person("小韩",18,"女");
    }
}
class Person{
    String name;
    int age;
    String sex;
    public Person(){
//构造方法首行name = null,age = 0;sex = null（不用写）
        System.out.println("Person类的无参构造");
    }
    public Person(String n){
//首行name = null,age = 0;sex = null;
        name = n ;
        System.out.println("name:"+name);
        System.out.println("Person类的一个参数的有参构造");
    }
    public Person(String n,int a){
        name = n ;
        age = a;
        System.out.println("name:"+name+", age:"+ age );
        System.out.println("Person类的两个参数的有参构造");
    }
    public Person(String n,int a,String s){
        name = n ;
        age = a;
        sex = s;
        System.out.println("name:"+name+", age:"+ age +", sex :"+sex);
        System.out.println("Person类的三个参数的有参构造");
    }
}

java类和对象的基本概念,java

 7.问题：能否用一个实例化对象去调用它的构造方法？

不能。 构造方法就是去产生对象，如果用构造方法产生的对象去调用产生它的构造方法，就相当于自己又在自己的构造方法（我生我自己）

java类和对象的基本概念,java

 注：JVM产生对象时调用构造方法，对象实例化结束，无法在程序中手动调用构造方法再次实例化对象的！！!

六、this 关键字（表示当前对象的引用）

（一）this关键字调用当前对象的成员变量

public class Test {
    public static void main(String[] args) {
        Person person = new Person("小韩",18,"女");
        person.print();
    }
}
class Person{
//成员变量
    String name;
    int age;
    String sex;
    public Person(String name,int age,String sex){//形参
        name = name;
        age = age;
        sex = sex;
        System.out.println("Person类的有参构造");
    }
    public void print(){
        System.out.println("name:"+name+", age:"+age+", sex:"+sex);
    }
}

java类和对象的基本概念,java

 问：为什么通过构造方法给成员变量初始化了，但输出结果仍是默认值？

形参名称与成员变量名称相同。程序设计理念：就近匹配原则，编译器会找最近的相同名称的变量在哪

java类和对象的基本概念,java

 问：如何打破就近匹配原则，从类中找同名变量呢？

使用this关键字

 public Person(String name,int age,String sex){
      this.name = name;
       this.age = age;
       this.sex = sex;
        System.out.println("Person类的有参构造");
    }

（二）this关键字调用当前对象的方法

（1）调用普通的成员方法

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.fun();
    }
}
class Student{
    String name;
    int age;
    String sex;

    public void test(){
        System.out.println("Student类的test成员方法");
    }
    public void fun(){
//test()方法是成员方法，必须通过对象调用
//this表示对象的引用，调用成员方法时不写，编译时也会自动加上
        test();//==this.test();
        System.out.println("Student类的fun成员方法");
    }
}

java类和对象的基本概念,java

（2）构造方法的相互调用

java类和对象的基本概念,java

 若不同参数的构造方法之间出现了重复的调用，可以使用 this（参数）调用其他的构造方法。

public Student(){
        System.out.println("*******");
    }
    public Student(String name){
  //调用无参构造
        this();
        this.name = name;
    }
    public Student(String name,int age){
//调用参数为name的一个参数的有参构造
        this(name);
        this.age = age;
    }

 注意要点：

1.this调用其他的构造方法必须放在当前构造方法的首行

java类和对象的基本概念,java

2.this调用构造方法不能成环（否则构造方法就死循环了）

 （三）this关键字表示当前对象的引用

（当前是通过哪个对象调用的属性或者方法，this就指代此对象）

public class Test {
    public static void main(String[] args) {
        Student student1 = new Student();
        System.out.println(student1);
        student1.fun();
        System.out.println();
        Student student2 = new Student();
        System.out.println(student2);
        student2.fun();
    }
}
class Student{
    String name;
    int age;
    String sex;

    public void fun(){
        System.out.println(this);
    }
    
}

 java类和对象的基本概念,java

 七、代码块

 代码块：指的是使用{ }括起来的一段代码，称为代码块。根据定义的代码块的位置以及关键字的不同分为以下四种代码块。

（一）普通代码块

定义在方法中，使用{ }括起来的一段代码。

  public static void main(String[] args) {

        //普通代码块

    }

（二）成员代码块

定义在类中，不加任何修饰符的代码块，又称构造块。优先于构造方法执行，有几个对象产生就调用几次构造块。

public class Test {
    public static void main(String[] args) {
        Student student1 = new Student();
        Student student2 = new Student();
    }
}
class Student{
    String name;
    {
        //构造块
        System.out.println("Student类的构造块");
    }
    public Student(){
        System.out.println("Student类的无参构造");
    }
}

java类和对象的基本概念,java

（三）静态代码块

定义在类中，使用static修饰的代码块，在类加载时执行一次，与对象无关。无论产生多少对象，静态代码块只在类加载时执行一次。

public class Test {
    public static void main(String[] args) {
        Student student1 = new Student();
        Student student2 = new Student();
    }
}
class Student{
    String name;
    {
        //构造块
        System.out.println("Student类的构造块");
    }
    public Student(){
        System.out.println("Student类的无参构造");
    }
    static {
        //静态代码块
        System.out.println("Student类的静态代码块");
    }
}

java类和对象的基本概念,java 主类中的静态代码块优先于主方法执行。（JVM要执行主方法，首先要加载主类，主类一加载，静态块就执行了）

public class Test {
    static {
        System.out.println("主类的静态代码块");
    }
    public static void main(String[] args) {
        System.out.println("进入主方法");
    }
}

java类和对象的基本概念,java 静态变量存在于方法区中，类定义时就会有初始值（在以下代码中，初始值为10），类此时在方法区中。但此时类只是定义了，还没被加载。当主方法中使用了该类时，就需要把该类从方法区加载到内存中。类加载后，静态代码块就被执行了（age= 10——>age = 100）

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(student.age);
    }
}
class Student{
   static int age = 10;
   static  {
       age = 100;
        System.out.println("Student类的静态代码块");
    }
    public Student(){
        System.out.println("Student类的无参构造");
    }
}

java类和对象的基本概念,java

（四）同步代码块（本篇博客暂不涉及）

八、其他

1.匿名对象：new出来的对象，没有引用指向，使用一次后就被JVM销毁。常用于测试类中的某些功能。

如 ：new Person();

2、toString方法（注意大小写）

当一个引用类型的变量调用println函数打印时，默认输出的都是引用类型的地址。（不是真正的内存地址，Java中程序员是无法知道任何确认的内存地址）

public class Test {
    public static void main(String[] args) {
        System.out.println(new Student("小王"));
        System.out.println(new Student("小李"));
    }
}
class Student{
  private String name;
   static  {
        System.out.println("Student类的静态代码块");
    }
    public Student(){
        System.out.println("Student类的无参构造");
    }
    public Student(String name){
        this.name = name;
        System.out.println("Person类的有参构造");
    }
}

java类和对象的基本概念,java

 在类中构造一个toString()方法，对象默认调用此方法进行打印。

 public String toString(){
        String ret = "name:"+this.name;
        return ret;
    }

java类和对象的基本概念,java文章来源地址https://www.toymoban.com/news/detail-783604.html

到了这里，关于Java基础——类和对象的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 初始Java篇（JavaSE基础语法）（5）（类和对象（上））

    初始Java篇（JavaSE基础语法）（5）（类和对象（上））

    个人主页（找往期文章包括但不限于本期文章中不懂的知识点）：我要学编程(ಥ_ಥ)-CSDN博客 目录 面向对象的初步认知 面向对象与面向过程的区别 类的定义和使用  类的定义格式 类的实例化 this引用 什么是this引用？ this引用的特性 对象的构造及初始化 如何初始化对象（的

    2024年04月08日
    浏览(46)
  • Java零基础手把手保姆级教程_类和对象（超详细）

    Java零基础手把手保姆级教程_类和对象（超详细）

    1.1 类和对象的理解 客观存在的事物皆为对象 ，所以我们也常常说万物皆对象。 类 类的理解 类是对现实生活中一类具有共同属性和行为的事物的抽象 类是对象的数据类型，类是具有相同属性和行为的一组对象的集合 简单理解：类就是对现实事物的一种描述 类的组成 属性：

    2024年02月05日
    浏览(45)
  • 【JAVA】类和对象

    【JAVA】类和对象

    作者主页：paper jie的博客 本文作者：大家好，我是paper jie，感谢你阅读本文，欢迎一建三连哦。 本文录入于《JAVASE语法系列》专栏，本专栏是针对于大学生，编程小白精心打造的。笔者用重金(时间和精力)打造，将javaSE基础知识一网打尽，希望可以帮到读者们哦。 其他专栏

    2024年02月14日
    浏览(31)
  • 【Java】类和对象详解

    【Java】类和对象详解

    面向对象（Object-oriented）是一种程序设计的方法和编程范式，它以对象作为程序的基本单位，通过封装、继承、多态等概念来组织和实现程序逻辑。面向对象的编程思想强调将问题分解为对象的集合，每个对象具有自己的状态（属性）和行为（方法），并通过相互之间的消息

    2024年02月06日
    浏览(44)
  • Java宝典-类和对象

    Java宝典-类和对象

    Java宝典更新啦!今天我们学习类和对象 在介绍类和对象之前,我们先了解一下什么是面向对象 面向对象编程又称Object Oriented Programming,简称OOP,我们听说过的Java,c++都是一门面向对象编程语言.面向过程更注重一件事完成的过程,而面向对象往往会省略一些细节. 举个例子: 如何把大

    2024年03月11日
    浏览(56)
  • 【Java】类和对象，封装

    【Java】类和对象，封装

    目录 1.类和对象的定义  2.new 3.this引用 4.对象的构造及初始化 5.封装 //包的概念 //如何访问 6.static成员 7.代码块 8.对象的打印 对象：Java中一切皆对象。 类：一般情况下一个Java文件一个类，每一个类对应一个字节码文件（*.class）        1）字段 / 属性 / 成员变量：定

    2024年02月02日
    浏览(42)
  • 【Java基础教程】（十五）面向对象篇 · 第九讲：抽象类和接口——定义、限制与应用的细节，初窥模板设计模式、工厂设计模式与代理设计模式~

    【Java基础教程】（十五）面向对象篇 · 第九讲：抽象类和接口——定义、限制与应用的细节，初窥模板设计模式、工厂设计模式与代理设计模式~

    掌握 抽象类和接口的定义、使用、区别、常见设计模式； 抽象类是代码开发中的重要组成部分，利用抽象类可以明确地定义子类需要覆写的方法，这样相当于在语法程度上对子类进行了严格的定义限制，代码的开发也就更加标准。下面具体介绍抽象类的概念。 普通类可以直

    2024年02月16日
    浏览(46)
  • Java中的类和对象

    Java中的类和对象

    在学习java语言的时候，经常听说java是一门 面向对象 的语言;在java里面也有 一切皆对象 这样的说法。那么到底什么是类，什么又是对象呢？ 以洗衣服为例，给大家介绍面向对象和面向过程 1.1.1面向过程 我们传统的洗衣服得经历一下步骤： 注重的是洗衣服的过程 1.1.2面向对

    2024年04月28日
    浏览(39)
  • 深度剖析java类和对象

    深度剖析java类和对象

    个人主页：兜里有颗棉花糖 欢迎 点赞👍 收藏✨ 留言✉ 加关注💓本文由 兜里有颗棉花糖 原创 收录于专栏【JavaSE_primary】 在Java中，一切皆对象。 在Java中，我们通过类来描述对象。 类的定义：Java类是面向对象编程中的基本构建模块， 用于描述对象的属性（成员变量）和行

    2024年02月10日
    浏览(42)
  • 【Java初阶（五）】类和对象

    【Java初阶（五）】类和对象

    ❣博主主页: 33的博客❣ ▶文章专栏分类: Java从入门到精通◀ 🚚我的代码仓库: 33的代码仓库🚚 Java是一门纯面向对象的语言(Object Oriented Program，简称OOP)，用面向对象的思想来涉及程序，更符合人们对事物的认知，对于大型程序的设计、扩展以及维护都非常友好，那么何为对

    2024年04月09日
    浏览(46)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包