Java全面细致讲解类与对象

目录
  • 类和对象的关系
  • 类和对象的实例化
  • static关键字
  • private实现的封装
  • 构造方法
  • this关键字
  • 代码块
  • 匿名对象
  • 小结

类和对象的关系

类就是一类对象的统称。对象就是这一类具体化的一个实例。 (对象是类的实例化)

对象是什么?

此对象非彼对象!!!说到对象就要提到过程。

面向过程:C语言是面向过程的,关注的是过程,分析出求解问题的步骤,通过函数调用逐步解决问题。面向过程注重的是过程,在整个过程中所涉及的行为,就是功能。

面向对象:JAVA是基于面向对象的,关注的是对象,将一件事情拆分成不同的对象,靠对象之间的交互完成。 面向对象注重的是对象,也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来 。

只能说这样解释起来很抽象,举个冰箱的例子。

面向过程:1.把冰箱打开 2. 把水果放入 3. 冰箱关起来

面向对象:冰箱。 打开冰箱,储存,关闭都是对冰箱的操作,是冰箱的行为。冰箱就是一个对象,所以只要操作冰箱所具备的功能,都要定义在冰箱中。

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

类和对象的实例化

怎么创建一个类:

// 创建类
class < class_name > {  
    field ; // 成员属性
    method ; // 成员方法
}
// 实例化对象
< class_name > < 对象名 > = new < class_name > ();
(类名称采用大驼峰命名方式)

举个例子:

public class TestModer {
    public static void main(String[] args) {
        Person person1 = new Person();
        person1.name = "张三";
        person1.age = 18;
        System.out.println(person1.name);
        System.out.println(person1.age);
        person1.eat();
        Person person2 = new Person();
        person2.name = "李四";
        person2.age = 20;
        System.out.println(person2.name);
        System.out.println(person2.age);
        person2.eat();
    }
}
    class Person {
        public String name;
        public int age;

        public void eat() {
            System.out.println("吃饭");
        }
    }

类中定义的变量可称为“字段”/“属性”/“成员变量”,类中定义的方法叫成员方法,我们可以知道一个类可以实例化多个对象,每个对象都有一个普通成员变量。

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

1. 类只是 一个 模型 一样的东西,限定了类有哪些成员 。

2. 一个类可以实例化出多个对象, 实例化出的对象占用实际的物理空间,存储类成员变量。

static关键字

成员变量分为普通成员变量和静态成员变量两种,普通成员变量上面已经说过了-->public String name;name就是普通成员变量,而用static修饰之后,就成为了静态成员变量。public static String name,name就成为了静态成员变量。下面来看个例子:

public class TestModer {
    public static void main(String[] args) {
        Person person1 = new Person();
        person1.age ++;
        Person.high++;
        System.out.println(person1.age);
        System.out.println(Person.high);
        Person person2 = new Person();
        person2.age++;
        Person.high++;
        System.out.println(person2.age);
        System.out.println(Person.high);
    }
}
    class Person {
        public int age;
        public static int high;
        public void eat() {
            System.out.println("吃饭");
        }
    }

注意:静态成员变量不可以放在其他方法中定义,静态变量属于类,不属于对象。

默认值:

static修饰的成员变量叫静态成员变量,static修饰的方法成为静态方法。

1、静态方法属于类,而不属于类的对象。

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

3、静态方法可以访问静态数据成员,并可以更改静态数据成员的值

4、静态方法内部不可以调用其他方法,但是其他方法内部可以调用静态方法。

看个例子:

    public static void main(String[] args) {
        Test.change();//无需创建实例对象 就可以调用
        System.out.println(Test.count);
    }
}
class Test{
    public int a;
    public static int count;

    public static void change() {
        count = 100;
        //a = 10; error 不可以访问非静态数据成员
    }
}

//结果为100

private实现的封装

什么叫封装:

<< 代码大全 >> 开篇就在讨论一个问题 : 软件开发的本质就是对程序复杂程度的管理 . 如果一个软件代码复杂程度太高 , 那么就无法继续维护 。 如何管理复杂程度 ? 封装就是最基本的方法 。 在我们写代码的时候经常会涉及两种角色 : 类的实现者 和 类的调用者 . 封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的 , 只要知道如何使用类就行了 .这样就降低了类使用者的学习和使用成本 , 从而降低了复杂程度。

private实现的封装:

private/ public 这两个关键字表示 " 访问权限控制 " .

被 public 修饰的成员变量或者成员方法 , 可以直接被类的调用者使用 .

被 private 修饰的成员变量或者成员方法 , 不能被类的调用者使用 .

换句话说 , 类的使用者根本不需要知道 , 也不需要关注一个类都有哪些 private 的成员 。 从而让类调用者以更低的 成本来使用类。

看个例子:

public class TestModer {
    public static void main(String[] args) {
        Person person = new Person();
        person.show();
    }
}
class Person{
    private String name = "张三";
    private int age = 18;
    public void show() {
        System.out.println("我叫" + name + ", 今年" + age + "岁");
    }
}

此时字段已经使用 private 来修饰 . 类的调用者 (main 方法中 ) 不能直接使用 . 而需要借助 show 方法。 此时类的使用者就不必了解 Person 类的实现细节。 同时如果类的实现者修改了字段的名字 , 类的调用者不需要做出任何修改 ( 类的调用者根本访问不到 name, age 这样的字段 )。

注意:

1、private 不光能修饰字段 , 也能修饰方法

2、通常情况下我们会把字段设为 private 属性 , 但是方法是否需要设为 public, 就需要视具体情形而定。 一般我们希 望一个类只提供 " 必要的 " public 方法 , 而不应该是把所有的方法都无脑设为 public。

现在有一个问题 类的实现者万一修改了 public 方法 show 的名字 , 岂不是类的调用者仍然需要大量修改代码 嘛 ?

这个时候我们就来看看 getter 和 setter 方法。

getter 和 setter 方法的使用:

public class TestModer {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("张三");
        String name = person.getName();
        System.out.println(name);
        person.show();
    }
}
class Person{
    private String name;//实例成员变量
    private int age;
    public void setName(String name){
        //name = name;//不能这样写
        this.name = name;//this引用,表示调用该方法的对象
    }
    public String getName(){
        return name;
    }
    public void show(){
        System.out.println("name: "+name+" age: "+age);
    }
}

字段已经使用 private 来修饰. 类的调用者(main方法中)不能直接使用,这时候我们可以借助getter和setter来使用,getName 即为 getter 方法, 表示获取这个成员的值。setName 即为 setter 方法, 表示设置这个成员的值。getter和setter可以不用手动输入,可以在类中点击右键按下图操作:

在这里我们是调用了show这个方法来实现打印,如果不调用方法,可以自带的to String进行打印。

to String用法:

public class TestModer {
        public static void main(String[] args) {
            Person person = new Person();
            person.setName("张三");
            String name = person.getName();
            System.out.println(name);
            //person.show();
            System.out.println(person);
        }
    }
    class Person{
        private String name;//实例成员变量
        private int age;

        public void setName(String name){
            //name = name;//不能这样写
            this.name = name;//this引用,表示调用该方法的对象
        }
        public String getName(){
            return name;
        }
        //public void show(){
            //System.out.println("name: "+name+" age: "+age);
        //}
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

toString 方法会在 println 的时候被自动调用 ,将对象转成字符串这样的操作我们称为 序列化 . toString 是 Object 类提供的方法 , 我们自己创建的 Person 类默认继承自 Object 类 , 可以重写 toString 方法实现我们自己版本的转换字符串方法。 快速生成toString的方法: 在类中点击鼠标右键,按下图操作:

构造方法

构造方法是一种特殊方法 , 使用关键字 new 实例化新对象时会被自动调用 , 用于完成初始化操作。

new 执行过程

  • 为对象分配内存空间
  • 调用对象的构造方法

语法规则

1.方法名称必须与类名称相同

2.构造方法没有返回值类型声明

3. 每一个类中一定至少存在一个构造方法(没有明确定义,则系统自动生成一个无参构造)

举个例子:

public class TestModer {
    public static void main(String[] args) {
            Person p1 = new Person();//调用不带参数的构造函数 如果程序没有提供会调用不带参数的构造函数
            p1.show();
            Person p2 = new Person("张三",80,"男");//调用带有3个参数的构造函数
            p2.show();
    }
}
class Person {
    private String name;//实例成员变量
    private int age;
    private String sex;
    //默认构造函数 构造对象
    public Person() {
        this.name = "王五";
        this.age = 10;
        this.sex = "男";
    }
    public Person(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }
}

注意事项 :

如果类中没有提供任何的构造函数,那么编译器会默认生成一个不带有参数的构造函数 。

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

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

this关键字

this 表示当前对象引用 ( 注意不是当前对象 ). 可以借助 this 来访问对象的字段和方法

this有三种用法:

1、this.date-->调用当前对象的属性。

2、this.func()-->调用当前对象的方法。

3、this()-->调用当前对象的其他构造方法。

前面两种方法我们之前都用过了,接下来我们来看看第三种用法。

class Person {
 private String name;//实例成员变量
 private int age;
 private String sex;
 //默认构造方法 构造对象
 public Person() {
 //this调用构造函数
 this("bit", 12, "man");//必须放在第一行进行显示
 }
 //这两个构造方法之间的关系为重载。
 public Person(String name,int age,String sex) {
 this.name = name;
 this.age = age;
 this.sex = sex;
 }
 public void show() {
 System.out.println("name: "+name+" age: "+age+" sex: "+sex);
 }
}
public class Main{
 public static void main(String[] args) {
 Person person = new Person();//调用不带参数的构造方法
 person.show();
 }

运行结果:

注意:this()必须放在第一行!!!否则会报错。

代码块

字段的初始化方式有:

1. 就地初始化

2. 使用构造方法初始化

3. 使用代码块初始化

前两种方式前面已经看过了 , 接下来我们介绍第三种方式 , 使用代码块初始化。

代码块可以分为四种:

1、普通代码块(也称本地代码块)

2、构造代码块(也称实例化代码块)

3、静态代码块

4、同步代码块

我们在这里主要认识第二种和第三种。

1、普通代码块

定义在方法中

  public static void main(String[] args) {
        { //直接使用{}定义,普通方法块
            int x = 10;
            System.out.println("x1 = " + x);
        }
    }
}

2、构造代码块

构造块:定义在类中的代码块 ( 不加修饰符 ) 。也叫: 实例代码块 。构造代码块一般用于初始化实例成员变量。

class Person {
    private String name;
    private int age=19;
    public static int count;
  //构造代码块
    {
        this.age = 99;
        System.out.println("构造代码块!");
    }

3、静态代码块

使用 static 定义的代码块。 一般用于初始化静态成员属性。

class Person {
    private String name;
    private int age = 19;
    public static int count;//0
   //静态代码块
    static {
        count = 99;
        System.out.println("静态代码块!");
    }
}

注意:

1、静态代码块不管生成多少个对象,其只会执行一次,且是最先执行的。

2、静态代码块执行完毕后 , 实例代码块(构造块)执行,再然后是构造函数执行。

匿名对象

1、匿名只是表示没有名字的对象 .

2、没有引用的对象称为匿名对象 .

3、匿名对象只能在创建对象时使用 .

4、如果一个对象只是用一次 , 后面不需要用了 , 可以考虑使用匿名对象。

来看个例子:

class Person {
 private String name;
 private int age;
 public Person(String name,int age) {
 this.age = age;
 this.name = name;
 }
 public void show() {
 System.out.println("name:"+name+" " + "age:"+age);
 }
}
public class Main {
 public static void main(String[] args) {
 new Person("caocao",19).show();//通过匿名对象调用方法
//Person person=new Person();//非匿名对象
 }
}

小结

以上就是类和对象的使用,一个类可以产生无数的对象,类就是模板,对象就是具体的实例。 类中定义的属性,大概分为几类:类属性,对象属性。其中被static所修饰的数据属性称为类属性, static修饰的方法称为类方法,特点是不依赖于对象,我们只需要通过类名就可以调用其属性或者方法。 静态代码块优先实例代码块执行,实例代码块优先构造函数执行。 this关键字代表的是当前对象的引用。并不是当前对象。如果有什么不正确的地方大家尽管说哦!

到此这篇关于Java全面细致讲解类与对象的文章就介绍到这了,更多相关Java类与对象内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java 超详细讲解类的定义方式和对象的实例化

    目录 1.面对对象的初步认识 1.1什么是面向对象 1.2面向对象与面向过程 2.类的定义与使用 2.1简单认识类 2.2 类的定义格式 3.类的实例化 3.1什么是实例化? 3.2重点笔记 总结 1.面对对象的初步认识 1.1什么是面向对象 用面向对象的思想来涉及程序,更符合人们对事物的认知,对于大型程序的设计.扩展以及维护都非常友好. 1.2面向对象与面向过程 举一个买手机的例子 以面向对象的方式来处理买手机这件事的话,我们就不需要关注买手机的过程,具体手机怎么买,如何到手,用户不用去关心,

  • 深入浅出分析Java 类和对象

    目录 一.什么是类 二.Java的类和C语言的结构体异同 三.类和类的实例化 类的声明 实例化的对象,成员遵循默认值规则 类的实例化 静态属性(静态成员变量) 四.构造方法 创建构造方法 this 一.什么是类 类(Class)是面向对象程序设计(OOP,Object-Oriented Programming)实现信息封装的基础.类是一种用户自定义的引用数据类型,也称类类型.每个类包含数据说明和一组操作数据或传递消息的函数,类的实例称为对象 类的实质是一种引用数据类型,类似于 byte,shor

  • Java十分钟理清面向对象与类的核心

    什么是对象? 一切客观存在的事物都是对象 对象的组成 属性.行为 类是什么? 类是对大量对象共性的抽象 类是客观事物在人脑中的主观反映 类是创建对象的模板 类的组成 属性.行为 简单的说,一个类就是把公有的特征写在一起,然后由这个类创建的对象,都会都这个属性. 例如人这个类 属性会吃饭,会说话.我们就是对象,我们属于人这个类,因此我们也会吃饭说话. Java中类的定义 语法: public class Student{ //在这里面写成员属性.成员方法 } //Student就是这个类的名字,这

  • Java 类与对象超基础讲解

    目录 什么是面向对象 面向过程与面向对象 类与对象的使用 类与对象的使用与说明 对象的初始化 this的使用 构造方法 this可以调用本类的构造方法 什么是面向对象 Java语言是一个纯面向对象的语言,面向对象的语言不仅只有Java,包括C++,PHP等 面向对象的编程思想简称 OOP(Object Oriented Programming),其基本特点就是封装,继承和多态. 面向过程与面向对象 想要弄清楚什么是面向对象,首先需要知道两者的区别 面向过程更注重程序的每一个步骤,用相应的函数来实

  • Java 精炼解读类和对象原理

    面向对象.面向过程 什么是类? 什么是对象? 这是非常抽象的两个概念!!!!!!!! 在说清楚类和对象的概念之前,给大家讲一下什么是面向对象.面向过程,以此来推出我们类和对象的概念. 面向过程:以洗衣服为例:拿盆.放水.放衣服.放洗衣粉.手搓.换水.拧干.晾衣服,这个过程就是面向过程.  面向对象:以洗衣服为例:人把衣服放进洗衣机,倒入洗衣粉,洗完晾干,不需要关心洗衣服整个过程是怎么完成的,只需要找对象,创建对象,使用对象.在好比我们使用toString函数,我们并不关心toString函数具体

  • JavaSE的类和对象你真的了解吗

    目录 1.基本概念 1.1面向对象 1.2类和对象 2.类的定义及使用 2.1定义 2.2类的实例化 3.this引用 3.1访问成员变量 3.2访问成员方法 3.3this引用的特性 4.构造方法 4.1构造方法的特点 4.2this在构造方法中使用 总结 1.基本概念 首先我们需要弄清楚几个概念:面向对象是什么.类是什么.对象又是什么?还是逐个来说 1.1面向对象 我们常说Java是面向对象的语言,C语言是面向过程的语言,那面向对象是什么,它和面向过程的区别在哪? 面向对象是解决问题的一种思

  • Java快速入门掌握类与对象及变量的使用

    目录 类 1.什么是类 2.想要知道Java中类是什么 3.怎么写一个类 对象 1.什么是对象 2.创建对象的格式 3.怎么使用对象中的属性 4.怎么使用对象中的行为 5.实例 变量 1.什么是局部变量 2.什么是成员变量 3.成员变量和局部变量的区别 类 1.什么是类 类是事物的属性(外在特征)和行为(具备的功能)的集合 2.想要知道Java中类是什么 我们要先知道现实生活中的类是什么,因为Java源于现实生活. 比如说人"类",为什么我们人类呢,因为我们什么都相似,我们都有共同的外

  • Java 深入浅出解析面向对象之抽象类和接口

    目录 抽象类 声明抽象类 声明抽象方法 案例 使用规则 接口 声明接口 案例 接口特性 抽象类和接口的区别 抽象类 java语言,声明类时 abstract class Db{} 说明Db类为抽象类. java语言中,抽象方法是说没有方法的实现(方法体)此方法为抽象方法,只有抽象类和接口中才可以有抽象方法. 声明抽象类 声明抽象类很简单,加个abstract关节字就行. public abstract class AA { } 声明抽象方法 在抽象类中声明一个抽象方法,抽象方法没有方法体,就是说

  • Java全面细致讲解类与对象

    目录 类和对象的关系 类和对象的实例化 static关键字 private实现的封装 构造方法 this关键字 代码块 匿名对象 小结 类和对象的关系 类就是一类对象的统称.对象就是这一类具体化的一个实例. (对象是类的实例化) 对象是什么? 此对象非彼对象!!!说到对象就要提到过程. 面向过程:C语言是面向过程的,关注的是过程,分析出求解问题的步骤,通过函数调用逐步解决问题.面向过程注重的是过程,在整个过程中所涉及的行为,就是功能. 面向对象:JAVA是基于面向对象的,关注的是对象,将一件事情

  • Java 超详细讲解类的定义方式和对象的实例化

    目录 1.面对对象的初步认识 1.1什么是面向对象 1.2面向对象与面向过程 2.类的定义与使用 2.1简单认识类 2.2 类的定义格式 3.类的实例化 3.1什么是实例化? 3.2重点笔记 总结 1.面对对象的初步认识 1.1什么是面向对象 用面向对象的思想来涉及程序,更符合人们对事物的认知,对于大型程序的设计.扩展以及维护都非常友好. 1.2面向对象与面向过程 举一个买手机的例子 以面向对象的方式来处理买手机这件事的话,我们就不需要关注买手机的过程,具体手机怎么买,如何到手,用户不用去关心,

  • Java全面细致讲解Wrapper的使用

    目录 一.概述 二.作用 三.使用 1. 基本数据类型-包装类的实例(装箱) 2. 包装类-基本数据类型(拆箱) 3. String-基本数据类型/包装类 4. 基本数据类型/包装类-String 5. 转换图 四.经典题目 一.概述 针对八种基本数据类型定义相应的引用类型—包装类(封装类). 二.作用 有了类的特点,就可以调用类中的方法,Java才是真正的面向对象. 八种基本数据类型与其包装类的对应关系: 基本数据类型 包装类 byte Byte short Short int Integer

  • Java全面细致讲解==和equals的使用

    目录 equals与== 1. ==的使用 1.1 概述 1.2 代码演示 2. equals的使用 2.1 概述 2.2 代码演示 3. ==和equals的区别 3.1 概述 3.2 代码演示 上篇博文:Java-多线程的使用 equals与== 1. ==的使用 1.1 概述 用于基本类型比较值时:只要两个变量的值相等,即为true. 用于引用类型比较引用(是否指向同一个对象)时,比较两个对象的地址值是否相同,即两个引用是否指向同一个对象实体,只有指向同一个对象时,==才返回true. 用

  • Java全面细致讲解Cookie与Session及kaptcha验证码的使用

    目录 Cookie 1. 概念 2. 创建Cookie 3. 服务器获取Cookie 4. Cookie的修改 5. Cookie的生命控制 6. Cookie的有效路径Path 7. Cookie应用-免用户名密码登录 Session 1. 概念 2. 创建和获取Session 3. Session域数据的存取 4. Session的生命周期的控制 5. 浏览器和Session的关联 kaptcha验证码 1. 使用 2. 验证码的切换 Cookie 1. 概念 是服务器通知客户端保存键值对的

  • Java超详细讲解类的继承

    目录 写在前面 1.子类的创建 1.1子类的创建方法 1.2调用父类中特定的构造方法 2.在子类中访问父类成员 3.覆盖 3.1覆盖父类中的方法 3.2用父类的对象访问子类的成员 4.不可被继承的成员和最终类 实例java代码 写在前面 类的继承可以在已有类的基础上派生出来新的类,不需要编写重复的代码,提高了代码的复用性,是面向对象程序设计的一个重要的特点,被继承的类叫做父类,由继承产生的新的类叫做子类,一个父类可以通过继承产生多个子类,但是与C++不同的是Java语言不支持多重继承,即不能由多

  • Java全面细致讲解final的使用

    目录 一.理解 二.作用 1. 修饰-类 2. 修饰-方法 3. 修饰-变量 3.1 修饰-成员变量(属性) 3.2 修饰-局部变量 三.经典题目 一.理解 final:最终的 二.作用 final 可以用来修饰的结构:类.方法.变量 1. 修饰-类 final 用来修饰一个类,表示此类不能被其它类所继承,提高安全性,提高程序的可读性. 比如:String类.System类.StringBuffer类… 代码演示: final class A{}class B extends A{ //错误,不

  • Java使用excel工具类导出对象功能示例

    本文实例讲述了Java使用excel工具类导出对象功能.分享给大家供大家参考,具体如下: package com.gcloud.common; import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Sheet; import org.apache.poi.xssf.streaming.SXSSFSheet; import

随机推荐