温馨提示×

温馨提示×

您好,登录后才能下订单哦!

密码登录×
登录注册×
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》

Java中的类和对象是什么意思

发布时间:2021-08-19 17:44:33 来源:亿速云 阅读:114 作者:chen 栏目:开发技术

本篇内容介绍了“Java中的类和对象是什么意思”的有关知识,在实际案例的操作过程中,不少人都会遇到这样的困境,接下来就让小编带领大家学习一下如何处理这些情况吧!希望大家仔细阅读,能够学有所成!

目录
  • 认识类和对象

    • 1.类、对象是什么?

    • 2.什么是面向对象?

    • 3.一个对象的产生过程是?

    • ?OOP语言的三大特征?

  • 类和对象的实例化

    • 类的定义:

      • 注意:

    • 实例化对象:

      • ①如何访问对象中的实例成员变量?

      • ②如何访问静态的数据成员?

      • 注意:

    • 方法:

      • 实例成员方法:

      • 静态成员方法

    • ?构造方法

      • ①访问实例成员方法

        • ②访问静态成员方法

        • static 关键字

          • 1.修饰属性:

            • 静态成员变量只有一份:

          • 2.修饰方法:

          • this 关键字

            • this 使用方法:

              • 举例1

                • 举例2

                • getter 和 setter方法

                  • 注意事项:

                  • 封装

                    • 封装的实现步骤:

                      • 举例:

                        • 输出结果:

                          • Java中的访问修饰符:

                            • 封装的作用:

                            • 代码块

                              • 实例代码块:

                                • 注意事项:

                              • 静态代码块:

                                • 注意事项:

                            • 静态 / 实例代码块异同点

                              认识类和对象

                              1.类、对象是什么?

                              类在Java中,也叫做自定义类型。

                              类就是一类对象的统称,对象就是这一类具体化的一个个例

                              可以把类想象成一个模板,把对象想象成实体,比如:建房子,会有图纸,然后根据图纸去建房子,一张图纸可建很多同样的房子。而图纸就是"类",建的房子就是"实体",通过一个类可以产生多个对象

                              2.什么是面向对象?

                              之前在初始Java篇简单讲述了Java的面向对象性,对比了面向对象和面向过程的不同

                              这里就不多说了 :https://blog.csdn.net/m0_47988201/article/details/118996045?spm=1001.2014.3001.5501.

                              面向对象是思考问题的一种方式,是一种思想

                              总的来说,面向对象就是用代码(类),来描述客观世界事物的一种方式,一个类主要包含一个事物的属性和行为

                              面向对象的好处是:将复杂的事情简单化,只要面对一个对象就行

                              之后,会从这三点进行深入学习:找对象—创对象—使用对象

                              3.一个对象的产生过程是?

                              ①给对象分配内存;

                              ②调用合适的构造方法

                              ?OOP语言的三大特征?

                              OOP:面向对象编程

                              三大特性:继承、封装、多态

                              类和对象的实例化

                              类的定义:

                              在Java中定义类,需要 class 关键字

                              类中包含的内容称为类的成员;属性主要是用来描述类的,称之为类的成员属性或者类成员变量;方法主要说明类具有哪些功能,称为类的成员方法

                              类的成员包括:字段、方法、代码块、内部类和接口等,此处只介绍前三个

                              语法格式:

                              class ClassName {
                              field ; …// 字段(成员属性) / 成员变量
                              method;// 行为 / 成员方法
                              }

                              举例:

                              class Person{
                                  //字段
                              	String name;
                              	int age;
                                  //行为
                                  public void eat(){
                                      System.out.println("eat()!");
                                  }
                                  public void sleep(){
                                      System.out.println("sleep()!");
                                  }
                              }
                              注意:
                              • 类名使用大驼峰命名法

                              • 字段 / 成员变量定义在方法外面、类的里面

                              • 实例成员变量存放在对象里

                              • Java中访问修饰限定符:

                              • private:私有的;public:共有的;protected:受保护的;什么都不写:默认权限 / 包访问权限

                              • 一般一个文件当中只定义一个类

                              • main方法所在的类必须要使用public修饰p

                              • ublic修饰的类必须要和文件名相同

                              实例化对象:

                              在Java中,通过关键字new,配合类名可以实例化一个对象

                              用类类型创建对象的过程,称为类的实例化

                              //实例化对象
                              Person person1 = new Person();
                              Person person2 = new Person();
                              Person person3 = new Person();
                              Person person4 = new Person();

                              Java中的类和对象是什么意思

                              ①如何访问对象中的实例成员变量?

                              通过对象的引用即可访问:对象的引用 . 成员变量

                              public static void main(String[] args) {
                              	//实例化一个对象
                              	Person person = new Person();
                              	//访问对象中的实例成员变量
                              	//通过对象的引用
                              	System.out.println(person.age);
                              	System.out.println(person.name);
                              }

                              Java中的类和对象是什么意思

                              ②如何访问静态的数据成员?

                              类名 . 静态成员变量

                              public static void main(String[] args) {
                              	Person per = new Person();
                              	System.out.println(Person.size);
                              }
                              注意:
                              • 同一个类可以创建多个实例

                              • new关键字用于创建一个对象的实例实例

                              • 成员变量,没有初始化,默认值为对应的 0 值

                              • 引用类型默认为null,简单类型默认为 0

                              • 特殊:char类型—"\u0000";boolean类型—false

                              • 使用 . 来访问对象中的属性和方法

                              • 静态成员变量不属于对象,属于类,且只有一份

                              方法:

                              实例成员方法:
                              public void eat(){
                                  System.out.println("eat()!");
                              }
                              public void sleep(){
                                  System.out.println("sleep()!");
                              }
                              静态成员方法
                              静态成员方法
                              public static func(){
                              	System.out.println("static::func()!");
                              }

                              ?构造方法

                              构造方法的方法名和类名相同,且没有返回值

                              构造方法作用: 实例化一个对象

                              class Person{
                                  private String name;
                                  private int age;
                                  public  Person(){
                                      System.out.println("Person!");
                                  }
                              	public Person(String name,int age){
                                      this.name = name;
                                      this.age = age;
                                      System.out.println("Person<String,int>");
                                  }
                              public class Test {
                                  public static void main(String[] args) {
                                      //写这行代码的时候,就会调用构造方法
                                      Person person1 = new Person();
                                      Person person2 = new Person("Huahua",18);
                              	 }
                              }

                              注意:

                              • 当没有提供构造方法的时候,编译器会自动提供一个没有参数的构造方法

                              • 若类中定义了构造方法,则默认的无参构造不再产生

                              • 什么时候调用构造方法取决于new对象时是否给参数

                              • 构造方法支持重载,规则和普通方法一致

                              ①访问实例成员方法

                              通过对象的引用进行访问:对象的引用 . 实例成员方法

                              public static void main(String[] args) {
                              	Person per = new Person();
                              	per.eat();
                              	per.sleep();
                              }

                              ②访问静态成员方法

                              类名 . 静态成员方法

                              public static void main(String[] args) {
                              	Person.func();
                              }

                              static 关键字

                              1.修饰属性:

                              Java静态属性和类相似,和具体的实例无关

                              即:同一个类的不同实例共用同一个静态属性

                              class Test{
                                  public int a = 0;
                                  public static int count;
                              }
                              静态成员变量只有一份:
                              public static void main(String[] args) {
                                  Test T = new Test();
                                  T.a++;
                                  Test.count++;
                                  System.out.println(T.a+" "+Test.count);
                              }

                              输出结果:

                              Java中的类和对象是什么意思

                              分析原因:

                              Java中的类和对象是什么意思

                              2.修饰方法:

                              在方法前应用 ststic 关键字,就把该方法称为静态方法

                              静态成员方法
                              public static func(){
                              	System.out.println("static::func()!");
                              }

                              注意:

                              • 静态方法内部不能访问非静态成员

                              • 静态方法属于类,不属于类的对象

                              • 可以直接调用静态方法,而无需创建类的实例

                              • 静态方法可以更改静态数据成员的值

                              • 静态方法中不能调用任何非静态方法

                              this 关键字

                              this 表示当前对象的引用

                              this 使用方法:

                              1、this . 属性名称 访问属性,指的是访问类中的成员变量,用来区分成员变量和局部变量

                              2、this . 方法名称 用来访问本类的成员方法

                              3、this();访问本类的构造方法,()中可以有参数的 如果有参数 就是调用指定的有参构造

                              举例1

                              访问属性 和 访问方法

                              class  Person{
                                  private String name;
                                  private int age;
                                  //调用属性
                                  public Person(String name, int age) {
                                      this.name = name;
                                      this.age = age;
                                  }
                                  //调用方法
                                  public void eat{
                                  	System.out.println(this.getName());
                                  }
                                  public String getName{
                                  	return name;
                                  }
                              }

                              举例2

                              访问构造方法

                              class Person{
                                  private String name;
                                  private int age;
                                  public  Person(){
                                  	// 访问构造方法
                                      this("Huahua",3);
                                      System.out.println("Person!");
                                  }
                                  public Person(String name,int age){
                                      this.name = name;
                                      this.age = age;
                                      System.out.println("Person<String,int>");
                                  }
                              }

                              注意事项:

                              • this() 不能使用在普通方法中 只能写在构造方法中

                              • this() 必须是构造方法中的第一条语句

                              getter 和 setter方法

                              当我们使用 private 来修饰字段的时候,就无法直接使用这个字段了,这就需要使用 getter 和 setter 方法

                              class Person{
                                  private String name;
                                  //setter方法给设施变量的值
                                  public String getName{
                                     	return name;
                                  }
                                  public void setName(String name){
                                      this.name = name;
                                  }
                              }

                              注意事项:

                              • getName 即为 getter 方法,表示获取这个成员的值

                              • setName 即为 setter 方法,表示设置这个成员的值

                              • 不是所有的字段都一定要提供 setter / getter 方法,而是要根据实际情况决定提供哪种方法

                              • 当 setter 方法的形参名字和类中的成员属性的名字一样时,如果不适用 this,相当于自赋值,this表示当前实例的引用

                              • 在IDEA中,可以使用Alt+F12,快速生成 setter / getter 方法

                              封装

                              封装:用private 来修饰属性 / 方法

                              类和对象阶段,主要研究的就是封装特性

                              class Student{
                                  private String name;
                                  public int age;
                                  public void func1(){
                                      System.out.println("func1()");
                                  }
                              }

                              如果一个属性 / 方法被 private 修饰之后,限定只能在类当中来使用

                              封装的实现步骤:

                              1、修改属性的可见性——设为private

                              2、创建getter / setter方法——用于属性的读写

                              3、在getter / setter方法中加入属性控制语句——对属性值的合法性进行判断

                              举例:

                              class Student{
                                  //成员变量私有化
                                  private int age;
                                  //setter方法给设施变量的值
                                  public void setAge(int age){
                                      if(age < 0){
                                          System.out.println("年龄无效!");
                                      }
                                      else{
                                          this.age = age;
                                      }
                                  }
                                  //提供一个公开的接口
                                  //使用getter方法获取赋值
                                  public int getAge(){
                                      return age;
                                  }
                              }
                              public class Test {
                                  public static void main(String[] args) {
                                      Student student = new Student();
                                      //检验
                                      student.setAge(-10);
                                      System.out.println(student.getAge());
                                  }
                              }

                              输出结果:

                              Java中的类和对象是什么意思

                              Java中的访问修饰符:

                              访问修饰符本类同包子类其他
                              private


                              public
                              protected
                              默认

                              封装的作用:

                              • 对象的数据封装特性,提高了程序的可复用性和可维护性,降低了程序员保持数据与操作内容的负担

                              • 对象的数据封装特性还可以把对象的私有数据和公共数据分离开,保护了私有数据,减少了可能的模块间干扰,达到降低程序复杂性、提高可控性的目的

                              建议:以后在设计类的时候,无特殊要求,所有的属性虽好都设置为私有的private ,一定要体现封装

                              代码块

                              使用 { } 定义的一段代码称为代码块

                              重点掌握代码块执行的先后顺序

                              分为四种:

                              普通代码块:在方法或语句中出现的{ }就称为普通代码块
                              实例代码块 (构造代码块)
                              静态代码块
                              同步代码块

                              实例代码块:

                              定义在类中且没有加static关键字的代码块

                              如果存在多个构造代码块,执行顺序由他们在代码中出现的次序决定,先出现先执行

                              特性:

                              {
                               System.out.println("实例代码块......");
                              }
                              注意事项:
                              • 实例代码块优先于构造方法执行,因为编译完成后,编译器会将实例代码块中的代码拷贝到每个构造方法第一条语句前

                              • 实例代码块只有在创建对象时才会执行

                              静态代码块:

                              static {
                               System.out.println("静态代码块......");
                              }
                              注意事项:
                              • 静态代码块不能存在于任何方法体内

                              • 静态代码块不能直接访问实例变量和实例方法,需要通过类的实例对象来访问

                              • 静态代码块不管生成多少个对象,其只会执行一次

                              • 静态成员变量是类的属性,因此是在JVM加载类时开辟空间并初始化的

                              • 如果一个类中包含多个静态代码块,在编译代码时,编译器会按照定义的先后次序依次合并,最终放在生成的<>方法中,该方法在类加载时调用,并且只调用一次

                              静态 / 实例代码块异同点

                              相同点: 都是JVM加载类后且在构造函数执行之前执行,在类中可定义多个,一般在代码块中对一些static变量进行赋值

                              不同点:静态代码块在非静态代码块之前执行,静态代码块只在第一次 new 时执行一次,之后不在执行。而非静态代码块每new一次就执行一次

                              “Java中的类和对象是什么意思”的内容就介绍到这里了,感谢大家的阅读。如果想了解更多行业相关的知识可以关注亿速云网站,小编将为大家输出更多高质量的实用文章!

                              向AI问一下细节

                              免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。

                              AI