类和对象初步认识

目录

1.类初步认识

2.this

2.1.this的引出

2.2 this的使用

3. 构造方法

4.封装 

4.1关于封装

4.2访问限定符 

5.练习

 6.内部类及对象的打印

         6.1实例内部类

6.2静态内部类 

6.3局部内部类 

1.类初步认识

1.1类是用来描述对象的，定义类需要用到class关键字：

//创建类    
class ClassName{//类名采用大驼峰
    field;//字段（属性）或者成员变量
    method;//行为或者成员方法---说明类具有哪些功能
}

class Person{//大驼峰
    //属性
    public int age;
    public String name;
    //行为
    public void eat(){//小驼峰
        System.out.println("吃饭！");
    }

}

类名:大驼峰；

方法名/变量名：小驼峰

注意事项：
1.一般一个文件中只有一个类；
2.main方法所在的类一般用public修饰：Eclipse默认会在public修饰的类中找main方法；
3.public修饰的类必须与文件名相同；
4.不要轻易修改public修饰的类的名称，如果要修改，用开发工具修改。

1.2 简单实例化

class Dog{
    //成员变量
    public String name;
    public String color;
    //方法
    public void barks(){
        System.out.println(name+"汪汪");
    }
    public void wag(){
        System.out.println(name+"摇尾巴");
    }

}


public class Test{
    public static void main(String[] args) {
        //实例化一个Dog对象；
        Dog dog1=new Dog();
        dog1.name="来福";
        dog1.color="黑色";
        System.out.println(dog1.name);
        System.out.println(dog1.color);
        dog1.barks();
        dog1.wag();
    }
} 

 

2.this

2.1.this的引出

public class TestDate {
    public int year;
    public int month;
    public int day;

    public void setDate(int y, int m, int d) {//局部变量优先
        year = year;
        month = month;
        day = day;

    }

    public void printDate() {
        System.out.println(year + "-" + month + "-" + day);
    }

    public static void main(String[] args) {
        TestDate testdate = new TestDate();
//        testdate.year  = 2022;
//        testdate.month = 12;
//        testdate.day = 23;
        testdate.setDate(2022,11,23);
        testdate.printDate();
    }
}

在这种情况下，我们发现结果是 0-0-0 并非是我们想要的。

2.1.1当形参名不小心与成员变量名相同：

• 是因为在setDate方法内部，局部变量优先，只是形参自己给自己赋值了，所以根本就没有到我们的成员变量里面。
• 改为

  public void setDate(int year, int month, int day) {//局部变量优先
      this.year = year;
      this.month = month;
      this.day = day;
  }

• this代表对当前对象的引用（谁调用这个方法，谁就是this)

2.2 this的使用

this.访问成员变量；

this.访问成员方法；

this()访问构造方法； -调用本类中其他的调用方法。

* 1.this的类型：对应类型引用，即对哪个对象调用就是那个对象的引用类型；

* 2.this只能在“成员方法”中使用；

* 3.在“成员方法”中，this只能引用当前对象，不能引用其他对象；

* 4.this是“成员方法”中第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法的对象的引用传递给该成员方法，this负责接收。

3. 构造方法

• 这个方法没有返回值，方法名与类名一样。 
• 在实例化对象的过程中（new)一定会调用构造方法。
• 当我们没有提供任何构造方法的时候，编译器会帮我们提供一个不带参数的构造方法。
• 当构造方法调用完之后，对象才实际产生。
• 构造方法可以重载；
• 构造方法中，可以通过this调用其他构造方法来简化代码（this不能形成环）

•  绝大多数情况下使用public来修饰，特殊情境下会被private修饰。

局部变量在使用时必须初始化，而成员变量在使用时会被默认初始化。

代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中。 

4.封装 

4.1关于封装

*面向对象程序的三大特性：封装 继承 多态

在类与对象阶段，主要研究的是封装特性，封装就是套壳屏蔽细节。

• 封装：将数据与操作数据的方法进行有机结合，隐藏对象属性与实现细节，进对外公开接口来和对象交互
• 权限->访问修改限定符进行修改

4.2访问限定符 

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起；访问权限用来控制方法或者字段能否直接在类外使用

软件包->为了更好的管理类，把多个类收集在一起成为一组。

包是对类，接口等封装机制的体现，是一种对类或者接口等的很好的组织方式，在一个工程中允许存在相同名称的类，只要不在同一个包就行。 

5.练习

由于static的存在不会使之出现空指针异常，a的类型也是A，a这个引用不指向任何的对象 。

静态成员的引用使用类.存在于方法区

static 修饰的变量是类变量或者修饰类的方法而不是方法的局部变量 ，随着类的创建而创建，随着类的销毁而销毁，而这里static int a=10;变成了局部变量，出了大括号就被销毁

• 这里的static修饰的是成员变量
• static修饰的方法里不能含有非静态的方法，所以如果写成func（），不new一个通过对象的引用访问是会报错的（或者就public static void func() )

3.0是double类型；

默认权限是不存在关键字的 

import也不能导入指定的包，只能导入一个具体的类

 

 假设A有构造方法A（int a)，则在类A的其他构造方法中,调用该构造方法和语句的格式应该是（A）

A.this(a)

B.A(a)

C.this.A(a)

描述

现有一个Data类，内部定义了属性x和y，在main方法中实例化了Data类，并计算了data对象中x和y的和。但是，Data类的定义存在错误，请你将这些错误修正过来，使得main方法中的求和逻辑可以正常执行。

输入描述：

两个整数

输出描述：

两个整数的和

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int x = scanner.nextInt();
            int y = scanner.nextInt();
            Data data = new Data(x, y);
            System.out.println(data.getX() + data.getY());
        }
    }
}

class Data {
    private int x;//都被封装了,就只能在当前类内使用
    private int y;

    public Data(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }
    public int getY() {
        return y;
    }
}

描述

采用封装的思想，为Person类定义年龄属性，要求：

修改年龄时判断其范围，若年龄小于0则按0输出，若年龄大于200则按200输出。

输入描述：

年龄整数值

输出描述：

1. 若年龄小于0则输出0；

2. 若年龄大于200则输出200；

3. 若年龄介于[0,200]之间则直接输出。

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Person p = new Person();
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int age = scanner.nextInt();
            p.setAge(age);
            System.out.println(p.getAge());
        }
    }

}
class Person {
    private int age;
    public void setAge(int age){
        if(age<0) this.age=0;
        else if(age>200) this.age=200;
        else this.age=age;
    }
    public int getAge(){
        return age;
    }

}

 6.内部类及对象的打印

• 内部类：定义在另一类中的类；（是封装的一种体现）
• 分为实例内部类（非静态内部类），静态内部类，局部内部类，匿名内部类......
• 外部类：定义在方法外部的类·；
• 虽然内部类和外部类共用一个源文件，但经过编译后，内部类会形成单独的字节码文件。

 6.1实例内部类

public class Outclass{
    class Interclass{
        
    }
}
//Outclass是外部类
//Interclass是内部类

6.1.1如何获取实例内部类/构造内部类的对象呢？ 

OuterClass outClass=new OuterClass();
OuterClass.InnerClass innerClass=outerClass.new InnerClass();

---

 6.1.2.实例内部类中不能有静态的成员变量

因为static属于类成员（类加载就会被执行），而实例内部类还需要对象的引用。

但是在static 后面加上final然后赋值（就相当于变成常量，final就是常量）就不会报错了。

final int A=10;

定义常量，常量是在程序编译的时候 确定的，一旦初始化就不能被修改了。

---

 6.1.3.当实例内部类与外部例中有相同的成员变量时，如何在实力内部类中访问外部的成员变量data1？ 

OutClass.this.data1
//在实力内部类方法中访问同名的成员时，优先访问自己的，
//访问外部：外部类名称.this.同成员名

---

6.1.4.实例内部类对象必须在先有外部类对象前提下创建。

6.1.5.实例内部类的非静态方法中包含了一个指向外部类对象的引用。

6.1.6.外部类不能直接访问实例内部类中的成员，如果要访问必须先创建内部类的对象。 

---

6.2静态内部类 

6.2.1如何获取静态内部类对象？

 

6.2.2静态类内部不能访问外部类的非静态成员，因为外部的非静态成员需要外部类对象的引用才能访问 。非要访问的话

 

6.3局部内部类 

匿名内部类先放着。

对象的打印：右键，generate+tostring()