Java中的类和对象

文章目录

  • 一、类和对象的基本概念
  • 二、类和对象的定义和使用
    • 1.创建类的语法
    • 2.创建类的对象
    • 3.范例(创建一个类的对象)
  • 三、this引用
    • 1.什么是this引用
    • 2.this引用的特性
  • 四、构造方法
    • 1.构造方法的概念
    • 2.构造方法的特性
  • 五、封装
    • 1.封装的概念
    • 2.访问限定符
    • 3.封装扩展包
      • 3.1包的概念
      • 3.2常见的包
  • 六、static成员
    • 1.static修饰成员变量
    • 2.static修饰成员方法
    • 3.static成员变量初始化
  • 七、代码块
    • 1.代码块的概念及分类
    • 2.普通代码块
    • 3.构造代码快
    • 4.静态代码块
  • 八、对象的打印


一、类和对象的基本概念

类和对象是整个面向对象中最基本的组成单元
:是抽象的概念集合,表示的是一个共性的产物,类之中定义的是属性和行为(方法);
对象:对象是一种个性的表示,表示一个独立的个体,每个对象拥有自己独立的属性,依靠属性来区分不同对象。

可以一句话来总结出类和对象的区别:类是对象的模板,对象是类的实例。类只有通过对象才可以使用,而在开发之中应该先产生类,之后再产生对象。类不能直接使用,对象是可以直接使用的

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

1.创建类的语法

在java中定义类时需要用到class关键字,语法如下:

class 类名称 {
 
成员变量/ 实例变量;
 
成员方法;
 
}

2.创建类的对象

格式一:声明并实例化对象

类名称 对象名称 = new 类名称 () ;

格式二:先声明对象,然后实例化对象

类名称 对象名称 = null ;
对象名称 = new 类名称 () ;

引用数据类型与基本数据类型最大的不同在于:引用数据类型需要内存的分配和使用。所以,关键字new的主要功能就是分配内存空间,也就是说,只要使用引用数据类型,就要使用关键字new来分配内存空间

当一个实例化对象产生之后,可以按照如下的方式进行类的操作:
对象.属性:表示调用类之中的属性;
对象.方法():表示调用类之中的方法

3.范例(创建一个类的对象)

class Person {
    //成员变量(实例变量),在堆中的每个对象中存储,通过对象调用
    String name;//默认值为null
    int age;//默认值为0
    String sex;//默认值为null
    //成员方法(实例方法),在JVM的方法区中存储,通过对象调用
    public void get() {
        System.out.println("姓名:" + name + " 年龄:" + age + " 性别:"+ sex);
    }
}
public class Test {
    public static void main(String[] args) {
        //创建一个实例化对象
        Person per = new Person();
        //通过对象来调用成员变量和方法
        per.name = "小郑";
        per.age = 20;
        per.sex = "男";
        per.get();
    }
}

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

三、this引用

class Data {
    public int year;
    public int month;
    public int day;
    public void setDay(int year, int month, int day){
        year = year;
        month = month;
        day = day;
    }
    public void printDate(){
        System.out.println(year + "/" + month + "/" + day);
    }
}
public class Test1 {
    public static void main(String[] args) {
        // 构造三个日期类型的对象 d1 d2 d3
        Data d1 = new Data();
        Data d2 = new Data();
        Data d3 = new Data();
        // 对d1,d2,d3的日期设置
        d1.setDay(2020,9,15);
        d2.setDay(2020,9,16);
        d3.setDay(2020,9,17);
        // 打印日期中的内容
        d1.printDate();
        d2.printDate();
        d3.printDate();
    }
}

以上代码定义了一个日期类,然后main方法中创建了三个对象,并通过Date类中的成员方法对对象进行设置和打印,代码整体逻辑非常简单,没有任何问题
但是仔细观察还是会发现有两个疑问
1.形参名不小心和成员变量名相同:

public void setDay(int year, int month, int day){
    year = year;
    month = month;
    day = day;
}

2.三个对象都在调用setDate和printDate函数,但是这两个函数中没有任何有关对象的说明,setDate和printDate函数如何知道打印的是那个对象的数据呢

1.什么是this引用

this引用指向当前对象(成员方法运行时调用该成员方法的对象),在成员方法中所有成员变量的操作,都是通过该引用去访问

class Data {
    public int year;
    public int month;
    public int day;
    public void setDay(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }
    public void printDate(){
        System.out.println(year + "/" + month + "/" + day);
    }
}

注意:this引用的是调用成员方法的对象

public static void main(String[] args) {
  Data d = new Data();
  d.setDay(2020,9,15);
  d.printDate();
}

2.this引用的特性

  1. this的类型:对应类类型引用,即哪个对象调用就是哪个对象的引用类型
  2. this只能在"成员方法"中使用
  3. 在"成员方法"中,this只能引用当前对象,不能再引用其他对象
  4. this是“成员方法”第一个隐藏的参数,编译器会自动传递,在成员方法执行时,编译器会负责将调用成员方法对象的引用传递给该成员方法,this负责来接收

四、构造方法

1.构造方法的概念

构造方法(也称为构造器)是一个特殊的成员方法,名字必须与类名相同,在创建对象时,由编译器自动调用,并且在整个对象的生命周期内只调用一次

class Date {
    public int year;
    public int month;
    public int day;
    // 构造方法:
    // 名字与类名相同,没有返回值类型,设置为void也不行
    // 一般情况下使用public修饰
    // 在创建对象时由编译器自动调用,并且在对象的生命周期内只调用一次
    public Date(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
        System.out.println("Date(int,int,int)方法被调用了");
    }
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
    }
}
public class Test {
    public static void main(String[] args) {
        // 此处创建了一个Date类型的对象,并没有显式调用构造方法
        Date d = new Date(1949,10,1); // 输出Date(int,int,int)方法被调用了
        d.printDate();
    }
}

Java中的类和对象_第1张图片
注意: 构造方法的作用就是对对象中的成员进行初始化,并不负责给对象开辟空间

2.构造方法的特性

1、构造方法:构造方法是类中非常特殊的一类方法,使用关键字new 实例化对象时实际上调用的就是该类的构造方法。
2.构造方法的作用就是产生对象
3.使用new关键字产生一个对象时,大致分为以下两步:
(1)为对象在堆中分配空间(空间大小由该类中成员变量的属性决定)
(2)调用对象的构造方法为对象成员变量赋值(当构造方法调用结束后,该对象初始化完成)
4.构造方法的语法规则
(1)方法名称与类名称完全相同
(2)构造方法没有返回值声明(不是void)
(3)一个类中至少存在一个构造方法,若没有显示定义,编译器会生成一个默认的无参构造

class Person {
    String name;
    int age;
    String sex;
    //构造方法和类的名称完全相同
    //没有返回值声明
    public Person(){
        System.out.println("无参数的构造方法");
    }
}

public class Data {
    public static void main(String[] args) {
        //创建一个对象默认调用该类的构造方法
        Person per = new Person();
    }
}

在这里插入图片描述

如果没有定义构造方法,编译器会默认生成一个无参数的构造方法

class Person {
    String name;
    int age;
    String sex;
}

public class Data {
    public static void main(String[] args) {
        //创建一个对象默认调用该类的构造方法
        Person per = new Person();
    }
}

在这里插入图片描述

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

class Person{
    String name;
    int age;
    String sex;
    public Person(String n){
        name = n ;
        System.out.println("Person类的有参构造");
    }
}
public class Data {
    public static void main(String[] args) {
        //创建一个对象默认调用该类的构造方法
        Person per = new Person();
    }
}

Java中的类和对象_第2张图片

6.构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)和在构造方法中,可以通过this调用其他构造方法来简化代码

class Data{
    int year;
    int month;
    int day;
    public Data(){//不带参数的构造方法
        //this.year = 1949;
        //this.month = 10;
        //this.day = 1;
        this(1949,10,1);
    }
    public Data(int year){
        this.year = year;
        System.out.println("带一个参数的构造方法");
    }

    public Data(int month, int day) {
        this.month = month;
        this.day = day;
        System.out.println("带两个参数的构造方法");
    }

    public Data(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
        System.out.println("带三个参数的构造方法");
    }
    public void printData(){
        System.out.println(year+"-"+month+"-"+day);
    }
}
public class Test2 {
    public static void main(String[] args) {
        Data data = new Data();
        data.printData();
    }
}

在这里插入图片描述
上述几个构造方法:名字相同,参数列表不同,因此构成了方法重载
注意:
this(…)必须是构造方法中第一条语句
不能形成环

五、封装

1.封装的概念

面向对象程序三大特性:封装、继承、多态。而类和对象阶段,主要研究的就是封装特性。何为封装呢?简单来说就是套壳屏蔽细节
封装:将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行 交互

2.访问限定符

Java中主要通过类和访问权限来实现封装:类可以将数据以及封装数据的方法结合在一起,更符合人类对事物的认知,而访问权限用来控制方法或者字段能否直接在类外使用
private(私有的):被private 修饰的属性和方法,只在当前类可见,出了类的{ },对外就完全隐藏了,外部不知道有其存在。
default(不需要写这个关键字,什么权限也没有(包访问权限))
protected(继承访问权限)
public(公共的、公开的):被public 修饰的,在当前程序(项目)中都是可见并且可以使用的

3.封装扩展包

3.1包的概念

在面向对象体系中,提出了一个软件包的概念,即:为了更好的管理类,把多个类收集在一起成为一组,称为软件包
在Java中也引入了包,包是对类、接口等的封装机制的体现,是一种对类或者接口等的很好的组织方式,比如:一个包中的类不想被其他包中的类使用。包还有一个重要的作用:在同一个工程中允许存在相同名称的类,只要处在不同的包中即可

3.2常见的包

  1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
  2. java.lang.reflect:java 反射编程包;
  3. java.net:进行网络编程开发包。
  4. java.sql:进行数据库开发的支持包。
  5. java.util:是java提供的工具程序包。(集合类等) 非常重要
  6. java.io:I/O编程开发包

六、static成员

在Java中,被static修饰的成员,称之为静态成员,也可以称为类成员,其不属于某个具体的对象,是所有对象所共享的

1.static修饰成员变量

static修饰的成员变量,称为静态成员变量,静态成员变量最大的特性:不属于某个具体的对象,是所有对象所共享的。
【静态成员变量特性】
1.不属于某个具体的对象,是类的属性,所有对象共享的,不存储在某个对象的空间中
2.既可以通过对象访问,也可以通过类名访问,但一般更推荐使用类名访问
3.类变量存储在方法区当中
4.生命周期伴随类的一生(即:随类的加载而创建,随类的卸载而销毁)

class Student {
    public String name;
    public String gender;
    public int age;
    public double score;
    public Student(String name, String gender, int age, double score) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.score = score;
        System.out.println("name:"+name+" gender:"+gender+" age:"+age+" score:"+score);
    }
    // 静态成员变量可以直接通过类名访问
    public static String classRoom = "Lzy306";
}
public class Test1 {
    public static void main(String[] args) {
        System.out.println(Student.classRoom);
        Student s1 = new Student("Li leilei", "男", 18, 3.8);
        Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
        Student s3 = new Student("Jim", "男", 18, 2.6);
        // 通过对象访问:classRoom是三个对象共享的
        System.out.println(s1.classRoom);
        System.out.println(s2.classRoom);
        System.out.println(s3.classRoom);
    }
}        

Java中的类和对象_第3张图片

2.static修饰成员方法

Java中,被static修饰的成员方法称为静态成员方法,是类的方法,不是某个对象所特有的。静态成员一般是通过静态方法来访问的
【静态方法特性】
1.不属于某个具体的对象,是类方法
2.可以通过对象调用,也可以通过类名.静态方法名(…)方式调用,更推荐使用后者
3.不能在静态方法中访问任何非静态成员变量
4.静态方法中不能调用任何非静态方法,因为非静态方法有this参数,在静态方法中调用时候无法传递this引用

3.static成员变量初始化

注意:静态成员变量一般不会放在构造方法中来初始化,构造方法中初始化的是与对象相关的实例属性
静态成员变量的初始化分为两种:就地初始化静态代码块初始化
1.就地初始化
就地初始化指的是:在定义时直接给出初始值

public class Student{
   private String name;
   private String gender;
   private int age;
   private double score;
   private static String classRoom = "Bit306";
}

2.静态代码块初始化
这个我们在代码块中讲解

七、代码块

1.代码块的概念及分类

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字,又可分为以下四种:
普通代码块
构造块
静态块
同步代码块(后续讲解多线程部分再谈)

2.普通代码块

public class Data {
    public static void main(String[] args) {
        {
            int i = 10;
            System.out.println("i="+i);
        }
        {
            int m = 20;
            System.out.println("m="+m);
        }
    }
}    

Java中的类和对象_第4张图片

3.构造代码快

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

class Student{
    //实例成员变量
    private String name;
    private String sex;
    private int age;
    public Student(){
        System.out.println("I am student");
    }
    //实例代码块
    {
        this.name = "小郑";
        this.sex = "男";
        this.age = 18;
        System.out.println("my student");
    }
    public void shou() {
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }
}
public class Test2 {
    public static void main(String[] args) {
        Student student = new Student();
        student.shou();
    }
}

Java中的类和对象_第5张图片

4.静态代码块

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量

class Student {
    private String name;
    private String sex;
    private int age;
    private static  String classroom;
    //实例代码块
    {
        this.name = "小郑";
        this .sex = "男";
        this.age = 20;
        System.out.println("I am student");
    }
    //静态代码块
    static {
        Student.classroom = "lzy502";
        System.out.println("you student");
    }
    public Student(){
        System.out.println("is student");
    }
}
public class Dome {
    public static void main(String[] args) {
        Student student1 = new Student();
        Student student2 = new Student();
    }
}

Java中的类和对象_第6张图片
注意:
1.静态代码块不管生成多少个对象,其只会执行一次
2.静态成员变量是类的属性,因此是在JVM加载类时开辟空间并初始化的
3.如果一个类中包含多个静态代码块,在编译代码时,编译器会按照定义的先后次序依次执行(合并)
4.实例代码块只有在创建对象时才会执行

八、对象的打印

class Student {
    String name;
    String sex;
    int age;

    public Student(String name, String sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
}

    public class Data {
    public static void main(String[] args) {
        Student student = new Student("小郑","男", 20);
        System.out.println(student);
    }
}    

在这里插入图片描述
如果想要默认打印对象中的属性我们可以重写toString

class Student {
    String name;
    String sex;
    int age;

    public Student(String name, String sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    @Override
    public String toString() {
        return "[" + name + "," + sex + "," + age + "]";
    }
}
    public class Data {
    public static void main(String[] args) {
        Student student = new Student("小郑","男", 20);
        System.out.println(student);
    }
}

在这里插入图片描述

你可能感兴趣的:(java,开发语言)