JAVA -- 类和对象

目录

一.Java内一切皆对象~

       二.类的实例化

        四.this 引用

         五.对象的构造及初始化

         六. 封 装 

        七.static成员

        八.代码块

        九.内部类

一.Java内一切皆对象~

        1.1 什么是面向对象

首先我们要知道的是面向对象是一种思想！

以面向对象方式来进行处理，就不关注做这件事的过程，具体是怎么干，用户是不考虑的，比如说洗衣服，洗衣机如何洗，怎么甩干，我们是不需要关心，我们只需将衣服放进洗衣机，导入洗衣粉等，通过对象之间的交互来实现

java是oop（面向对象程序） ！！！

        1.2类的定义和使用

class 类名{
    属性 ： 成员属性（字段）
    行为 ： 成员方法（方法）
}

我们要注意的是类名要用大驼峰！

ps：

1.一般一个文件当中只定义一个类。

2.main方法要用publi修饰

3.public修饰的类必须要和文件名相同

4.不要轻易修改public修饰的类的名字，如果要修改：Refactor-Rename修改

       二.类的实例化

3.1 实例化

        定义一个类 == 定义一种新的类型

class Dog1{
    public String name;
    public String color;
    public void braks(){
        System.out.println(name+"汪汪叫");
    }
    public void wag(){
        System.out.println(name+"摇尾巴");
    }

}

public class Main {
    public static void main(String[] args) {
        Dog1 dog = new Dog1();    定义一个对象
        dog.name = "来福";
        dog.braks();
    }

 

 

方法不占用内存，只有在使用的时候，在栈上开辟！！

而且，通过一个类可以实例无数个对象！

大家如果还难以理解的话

我们可以把类当成建筑房屋的图纸，我们通过这一图纸可以造很多的房子，这些房子就是对象，这就是实例化对象

        3.2 类和对象的说明

1.类只是一个模型一样的东西，用来具体化一个实体进行描述，限定了类有哪些成员

2.类只是一个自定义的类型，可以用来定义变量

3.一个类可以实例化无数个对象，实例出的对象，占用实际的物理空间，存储类成员变量

        四.this 引用

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

这里如果不加this.就会出现打印默认值：因为局部变量优先，形参给自己赋值了没赋值到变量中！

注意事项：

1.点号前的cat就可以让程序知道该设置哪个对象

2，this：当前对象的引用，谁调用这个方法，谁就是this！ 

3.在成员方法中，this只能引用当前对象，且只能在成员方法中使用。

this用法归纳：
1.this访问成员变量：this.

2.this访问成员方法：this.

3.this访问构造方法：this()--->即将讲解

         五.对象的构造及初始化

1.初始化可分为：

        默认初始化

   就地初始化

构造方法

 ①就地初始化：

public String name = "张三"
public int age = 27;

②构造方法:        这个没有返回值

        方法名与类名相同！

先看一下简单的例子来感受构造方法！

这里Student（）是不带参数的构造方法，但是如果我们不写这个构造方法，编译器还是会自动加入的

接下来我们在此基础上写一个带参数的

这里我们看出Student类里有俩个构造方法，但当我们在new的同时传参的话，就自动调用有形参接受的构造方法！！ 

1.并且构造方法可以被重载

2.当构造方法被调用完成之后，对象才实际产生，换言之就是先构造方法，实例化的对象才真正意义实现！

3.当没有构造方法的时候，编译器自动加一个

4.如果在调用本类当中 其他的构造方法：

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

public Student(){
      //必须在构造方法中的第一行！
      this("wangwu",18);
}

         六. 封 装 

对类内部的实现细节 进行隐藏/封装。

对外 只提供一些公开的接口 供其他用户访问

需要权限（通过访问修饰符）

private 只能对当前类的内部进行访问

default是默认的：如果不加修饰词自动加入 也叫包访问权限

public：在哪使用都可以

class Person{

    private String name;
    //此时name只能在当前类内部进行访问
    
    public int age;
}

 我们可以提供一个setName方法 然后在main里调用该方法     实现封装

show也可以写成sout(this.show());

        6.2 包

我们可以把包理解为 文件夹

文件夹里面的文件就是类

在Java中也引入了包，包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，比如：一
个包中的类不想被其他包中的类使用。包还有一个重要的作用：在同一个工程中允许存在相同名称的类，只要处在
不同的包中即可。 

可以通过以下代码来理解

或者使用import

假设 如果需要使用 java.util 中的其他类, 可以使用 import java.util.*

        七.static成员

        7.1 static 

static 修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的

         7.2 static 修饰成员变量

 访问用---"类名."

1.静态的不依赖于对象（不用this）用类名访问

2.在静态方法内部类，不能直接访问非静态的数据成员和数据方法

3.不能在方法内 定义一个 静态（局部） 变量

特性：

1.不属于某个具体的对象，类的属性，所有对象共享，不存储在某个对象空间内

2.static修饰的变量存在方法区

3.其伴随类的一生

       

        7.3 static 修饰成员方法

1.访问private成员

public class Student{
  private static String classRoom = "Bit306";
 
 
  public static String getClassRoom(){
    return classRoom;
 }
}
public class TestStudent {
  public static void main(String[] args) {
    System.out.println(Student.getClassRoom());
 }
}

2.

 

public static String getClassRoom(){
  System.out.println(this);
  return classRoom;
}
// 编译失败：Error:(35, 28) java: 无法从静态上下文中引用非静态 变量 this
public static String getClassRoom(){
  age += 1;
  return classRoom;
}
// 编译失败：Error:(35, 9) java: 无法从静态上下文中引用非静态 变量 age

 以此可看 在静态方法内不能访问任何非静态成员变量

3.静态方法不能重写

 4. 静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用

        八.代码块

代码块可分为：

                      实例代码块

                静态代码块：类加载时就被执行

        局部代码块

实例代码块在创建对象时执行，静态则在加载类

其代码块主要作用：

        给先前定义的变量赋值

        九.内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。在 Java 中，可以将一个类定义在另一个类或者一个方法的内部，
前者称为内部类，后者称为外部类。内部类也是封装的一种体现。

内部类可分为：

                        实例内部类

                静态内部类

        局部内部类（定义在方法中，不常用）

匿名内部类 

①实例内部类

        InnerClass就是实例内部类

class OuterClass{
    public int data1;
    int data2;
    public static int data3;
     
    public void test(){
           System.out.println("Out::test");
    }

class InnerClass{
    public int data4;
    int data5;
    //不能加static
    
    public void func(){
        System.out.println("In::test");
    }
}

        9.1 如何获取实例内部类的对象

① 

// 创建实例内部类对象
    OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();
    

②

    OutClass.InnerClass innerClass2 = outClass.new InnerClass();
    innerClass2.methodInner();

要注意的是：

实例内部类 不能有static 修饰的静态成员变量

除非：

public static final int data6 = 10;

以上就是定义常量

        那我们如何获取外部类？

加this！

OutClass.this.data1

        9.2 静态内部类

获取：

Outerclass2.InnerClass2 innerclass2 = new OuterClass2.InnerClass2();

静态内部类，不能访问外部类的非静态成员，外部类的非静态成员，需要通过外部类的对象的引用才能访问。

静态内不能访问外部非静态

        9.3 匿名内部类

System.out.println(new Person().age);//匿名对象，只能用一次
//每次使用都要new