神奇cpp

这个屌丝很懒，什么也没留下！

热门标签

JAVA类和对象_class test { private static string name; static {

作者：神奇cpp | 2024-08-21 09:21:35

踩

class test { private static string name; static { name = "world"; system.out

面向对象

面向对象是一种思想

类的定义和使用

将实体抽象为类

定义格式

使用class关键字


//创建类
class ClassName{
    field;        //字段（属性） 或者 成员变量
    method;       //行为 或者 成员方法
}

class:类的关键字

ClassName：类名

{ }：类主体


class washMachine{
    //属性
    public String brand;    //品牌
    public String type;    //型号
    public double weight;    //重量
    public double length;    //常量
    
    //成员方法
    public void wahsClothes(){
        System.out.println("洗衣功能");    
    }
    
    public void dryClothes(){
        System.out.println("脱水功能");    
    }
}

Java语言，javac编译后形成class文件，在JVM的基础上计算机可以识别

注意事项

类名注意采用大驼峰定义

成员前写法统一为public（暂时如此，后期详细介绍）

此处写法不带static关键字，（后面详细解释）

练习

学生类

学生：

属性：姓名、年龄、性别等等

方法：上课、写作业


public class Student{
    public String name;
    public String gender;
    public short age;
    
    public void doClass(){
        System.out.println("上课！");
    }
    
    public void doHomework(){
        System.out.println("写作业！");    
    }
}

注意事项

一个文件一般只定义一个类
main方法所在类一般要用public修饰
public修饰的类必须与文件名相同
不要轻易修改public修饰的类的名称（通过右键，refactor->rename）

类的实例化

实例化

定义了一个类，相当于在计算机中定义了一种新的类型。（用户自定义的新类型）

类类型为引用类型

实例化为其开辟内存空间


public class Main{
    public static void main(String[] args){
        Student stu1=new Student();
        Student stu2=null;
        stu1.name="张三";
        stu1.gender="男";
        stu1.age=16;
        
        stu1.doClass();
    }
}

用类类型创建对象的过程称为实例化，配合new关键字，配合类名实例化对象。

注意事项

new关键字用于创建一个对象的实例
使用 . 来访问对象中的属性和方法
同一个类可以创建多个实例

this引用

java编译器给每个“成员方法“增加了一个隐藏的引用类型参数，该引用参数指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。


public class Date {
    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(this.year + "/" + this.month + "/" + this.day);
}
/*隐藏的引用类型参数
    public void setDay(Date this,int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
    } 
    public void printDate(Date this){
        System.out.println(this.year + "/" + this.month + "/" + this.day);
 */

this引用是编译器自动添加的，用户在实现代码时一般不需要显式给出。

局部变量与成员变量同名时，局部变量优先（）

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

this引用特性

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

2. this只能在"成员方法"中使用

3. 在"成员方法"中，this只能引用当前对象，不能再引用其他对象，具有final属性

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

在代码层面来简单演示--->注意：下图右侧中的Date类也是可以通过编译的

对象的构造及初始化

构造方法

概念

构造方法（构造器）是一个特殊的成员方法。

名字必须与类名相同，没有返回值类型（设置void也不行）
一般情况下用 public 修饰
创建对象时，由编译器自动调用，且只调用一次
构造方法可以重载（可以根据需求提供不同的参数的构造方法）
没有显示定义构造方法时，编译器默认生成无参构造方法，有构造方法时，不生成默认的无参构造方法
可以通过this调用其他构造方法简化代码


public class Date{
    public int year;
    public int month;
    public int day;
    
    //无参构造
    public Date(){
        this.year=1900;
        this.month=12;
        this.day=23;    
    }
    /*简化
     public Date(){
         this(1900,12,23);
     }
    */
    
    //带参构造
    public Date(int year,int month,int day){
        this.year = year;
        this.month = month;
        this.day = day;    
    }
}

注意：

this（...）必须时构造方法中的第一条语句

不能形成环


public Date(){
    this(1900,1,1);
}
public Date(int year,int month,int day){
    this();
}
* 
无参
构造器调用三个参数的构造器，而三个参数构造器有调用无参的构造器，形成构造器的递归调用
编译报错：Error:(19, 12) java: 递归构造器调用
*/

绝大多数情况下使用public来修饰，特殊场景下会被private修饰(后序讲单例模式时会遇到)

默认初始化

为什么局部变量在使用时必须要初始化，而成员变量可以不用呢？

要搞清楚这个过程，就需要知道 new 关键字背后所发生的一些事情

Date d=new Date(2021,6,9);

在程序层面只是简单的一条语句，在JVM层面需要做好多事情，下面简单介绍下：

1. 检测对象对应的类是否加载了，如果没有加载则加载

2. 为对象分配内存空间

3. 处理并发安全问题

比如：多个线程同时申请对象，JVM要保证给对象分配的空间不冲突

4. 初始化所分配的空间

即：对象空间被申请好之后，对象中包含的成员已经设置好了初始值，比如：

5. 设置对象头信息(关于对象内存模型后面会介绍)

6. 调用构造方法<>，给对象中各个成员赋值

就地初始化

在声明成员变量时，就直接给出了初始值（不推荐）


public class Date {
    public int year = 1900;
    public int month = 1;
    public int day = 1;
    
    public Date(){
    } 
    
    p
ublic Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;    
    }
    
    p
ublic static void main(String[] args) {
        Date d1 = new Date(2021,6,9);
        Date d2 = new Date();
    }
}

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

封装

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

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互

访问限定符

Java中主要通过类和访问权限实现封装：类可以将数据以及封装数据的方法结合在一起

访问权限用来控制方法或者字段能否直接在类外使用

N	范围	private（本类）	default（本包）	protected	public(任何)
1	同一包中的同一类	√	√	√	√
2	同一包中的不同类		√	√	√
3	不同包中的子类			√	√
4	不同包中的非子类				√

【说明】

protected主要是用在继承中，继承部分详解

default默认权限：什么都不写时的默认权限

访问权限除了可以限定类中成员的可见性，也可以控制类的可见性

注意：一般情况下成员变量设置为private，成员方法设置为public。

当成员变量设置为private时，外部无法访问，可以通过定义set/get成员方法来修改或获取成员变量


public class Student{
    //成员变量
    private String name;        
    private String gender;
    short age;                //default属性
    
    //构造方法
    public Student(){
        this(null,null,0);
    }
    
    public Student(String name,String gender,short age){
        this.name=name;
        this.gender=gender;
        this.age=age;
    }
    
    //成员方法
    //set get方法
    public void setName(String name){
        this.name=name;    
    }
    public String getName(){
        return this.name;    
    }
    
    public void doClass(){
        System.out.println("上课！");
    }
    
    public void doHomework(){
        System.out.println("写作业！");    
    }
}

封装扩展之包

在面向对象体系中，提出了软件包的概念：为了更好的管理类，将多个类收集在一起称为一组，称之为软件包。

在Java中也引进了包，包是对类，接口等封装机制的体现，是一种对类或接口等的很好的组织方式。

而且，在同一个工程中允许存在相同名称的类，只要处在不同的包中即可

导入包中的类

Java中提供了很多现成的类供我们使用。

例如：Date类可以使用 java.util.Date 导入 java.util 这个包中的 Date 类.

方式一：


public class Test{
    public static void main(String[] args){
        java.util.Date date = new java.util.Date();
        //得到一个毫秒级别的时间戳
        System.out.println(date.getTime());    
    }
}

方式二：使用import 语句导入包


import java.util.Date;
public class Test{
    public static void main(String[] args){
        Date date = new Date();
        //得到一个毫秒级别的时间戳
        System.out.println(date.getTime());    
    }
}

如果需要使用 java.util 中的其他类, 可以使用 import java.util.* (导入包中的所有类)


import java.util.*;
public class Test{
    public static void main(String[] args){
        Date date = new Date();
        //得到一个毫秒级别的时间戳
        System.out.println(date.getTime());    
    }
}

但是我们更建议显式的指定要导入的类名. 否则还是容易出现冲突的情况


import java.util.*;
import java.sql.*;
public class Test {
    public static void main(String[] args) {
    // util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
    Date date = new Date();
    System.out.println(date.getTime());
    }
} 
/
/ 编译出错
Error:(5, 9) java: 对Date的引用不明确
java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配

使用 import static 导入包中静态的方法和字段。


import static java.lang.Math.*;
public class Test {
    public static void main(String[] args) {
    double x = 30;
    double y = 40;
    // 静态导入的方式写起来更方便一些.
    // double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
    double result = sqrt(pow(x, 2) + pow(y, 2));
    System.out.println(result);
    }
}

注意事项: import 和 C++ 的 #include 差别很大. C++ 必须 #include 来引入其他文件内容, 但是 Java 不需要. import 只是为了写代码的时候更方便. import 更类似于 C++ 的 namespace 和 using

自定义包

基本规则

在文件的最上方加上一个 package 语句指定该代码在哪个包中.
包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如com.bit.demo1 ).
包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储代码.
如果一个类没有 package 语句, 则该类被放到一个默认包中.

操作步骤

1.在IDEA中新建一个包：右键src -> 新建（new）-> 包（package）

2.弹出窗口输入对话框

分开显示，点击

设置图案

C.. M.. Package对勾消失即可分开显示

3.在包中创建类，编写代码即可

由IDEA创建出的包，其中创建的类会自动出现 package 语句

包的访问权限举例

Computer类位于com.bit.demo1包中，TestComputer位于com.bit.demo2包中：


package com.bit.demo1;
 
public class Computer{
    private String cpu;            //private
    private String memory;
    public String screen;          //public
    String brand;                  //default
    
    public Computer(String brand,String cpu,String memory,String screen){
        this.brand = brand;
        this.cpu = cpu;
        this.memory = memory;
        this.screen = screen;            
    }
    
    public void Boot{
        System.out.println("开机~~");    
    }
}
 
 
 
package com.bite.demo2
 
import com.bite.demo1.Computer;
public class TestComputer {
public static void main(String[] args) {
    Computer p = new Computer("HW", "i7", "8G", "13*14");
    System.out.println(p.screen);
    // System.out.println(p.cpu); // 报错：cup是私有的，不允许被其他类访问
    // System.out.println(p.brand); // 报错：brand是default，不允许被其他包中的类访问
    }
} 
/
/ 注意：如果去掉Computer类之前的public修饰符，代码也会编译失败

常见的包

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修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的。

以Student类为例，姓名等信息为学生对象特有，但是学校确实相同，如何存储呢？类中再添加一个成员变量存储学校？不可以，在类中定义的的属性，每个对象都会包含一份（称为实例遍历），资源浪费。该属性只需要让所有学生共享即可。

static 修饰成员变量

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

【静态成员变量特性】

不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
既可以通过对象访问，也可以通过类名访问（推荐）
static修饰成员变量存储在方法区，（JDK8之后，逻辑上方法区，在堆区）
生命周期伴随类的一生（随类的加载而创建，随类的卸载而销毁）


public class Student{
    private name;
    private age;
    public static String school;
    //....
}
 
public static void main(String[] args){
    Student s1=new Student();
    s1.school;
    Student.school;//推荐 类名访问
}

以调试方式运行上述代码，然后在监视窗口中可以看到，静态成员变量并没有存储到某个具体的对象中

static 修饰成员方法

一般类中的数据成员都设置为private，而成员方法设置为public，那设置之后，Student类中school属性如何在类外访问呢？


public class Student{
    private name;
    private age;
    private static String school;
    //....
}
 
public static void main(String[] args){
    Student s1=new Student();
    s1.school;
    Student.school;//推荐 类名访问
}
编
译失败：
Error:(10, 35) java: school 在 extend01.Student 中是 private 访问控制

如何访问？

java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的。


public class Student{
    //....
    private static String school;
    //....
    
    public static String getSchool(){
        return school;    
    }
}

【静态方法特性】

不属于某个具体的对象，是类方法
可以通过对象调用，推荐使用类名.静态方法名(...)方式调用
静态方法没有隐藏的this引用参数，所以不能在静态方法中访问任何非静态成员变量（不依赖对象）
静态方法中不能调用任何非静态方法，非静态方法中有this引用参数（不依赖对象）,在静态方法中调用时无法传递this引用。

如果要使用非静态成员或方法，则创建一个对象再使用


public class Student{
    private name;
    private age;
    private static String school;
    //....
    
    public static void print(){
        Student stu=new Student();
        System.out.println(stu.name);
        System.out.println(school);
    }
}

静态方法无法重写，不能用来实现多态（多态，详解）

static成员变量初始化

静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的时与对象相关的实例属性

就地初始化

在定义时直接给出初始值


public class Student{
    //....
    private static String school="sust";
    //....
    
    public static String getSchool(){
        return school;    
    }
}

静态代码块初始化

先了解代码块

代码块

概念

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

根据代码块定义的位置以及关键字，分为四种

普通代码块

构造快

静态块

同步代码块（后序多线程在详解）

普通代码块

定义在方法中的代码块


public class Main{
    public static void main(String[] args){
        {
            //直接使用{}定义，普通方法块
            int x=10;        //生命周期只在代码块中
            System.out.println(x);        
        }    
        int x=1;
        System.out.println(x);
    }
}

这种用法少见！

构造代码块

定义在类中的代码块（不加修饰符）。

也叫：实例代码块。

一般用于初始化实例成员变量


public class Student{
    private String name;
    private short age;
    
    public Student(){
        System.out.println("构造方法");    
    }
    
    //实例代码块
    {
        this.name="bit";
        this.name=20;
        System.out.println("实例代码块");    
    }
}
 
public class Main{
    public static main(String[] args){
        Student stu = new Student();    
    }
}
 
//运行结果
实例代码块
构造方法

注意事项

实例代码块优先于构造方法执行，因为编译完成后，编译器会将实例代码块中的代码拷贝到每个构造方法第一条语句前。

静态代码块

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


public class Student{
    private String name;
    private short age;
    private static String school;
    
    public Student(){
        System.out.println("构造方法");    
    }
    
    //实例代码块
    {
        this.name="bit";
        this.name=20;
        System.out.println("实例代码块");    
    }
    
    //静态代码块
    static{
        school="sust";
        System.out.println("静态代码块");    
    }
}
 
public class Main{
    public static main(String[] args){
        Student stu1 = new Student();   
        Student stu2 = new Student();   
    }
}

注意事项

静态代码块不管生成多少对象，只会执行一次
静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的

Java代码在经过编译器编译之后，如果要运行必须先要经过类加载子系统加载到JVM中才能运行。在加载阶段：

在链接阶段第二步准备中会给静态成员变量开辟空间，并设置为默认值，在初始化阶段，会执行静态代码块中的代码。(了解：关于类加载过程后序JVM中会详细讲解)

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

按先后顺序，谁在后，变量值为谁

结果 year=1;

year=100;

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

内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类

在 Java 中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。内部类也是封装的一种体现


public class OutClass {
    public class InnerClass{
    
    }
} 
/
/ OutClass是外部类
// InnerClass是内部类

注意实项

在定义在class类名 {}花括号外部的，即使在一个文件里，都不能称为内部类


public class A{
    
}
 
class B{
    
}
//A 和 B是两个独立的类，彼此之间没有关系

内部类和外部类公用一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件

分类


public class OutClass{
    //成员位置定义：违背static修饰 --->  普通内部类
    public class InnerClass{
            
    }
    
    //成员位置定义：被static修饰 --->    静态内部类
    static class InnerClass2{
            
    }
    
    public void method(){
        //方法中定义内部类 --->    局部内部类：几乎不用
        class InnerClass3{
                    
        }    
    }
}

根据内部类定义的位置不同，一般可以分为以下几种形式：

1. 成员内部类(普通内部类：未static修饰的成员内部类和静态内部类：被static修饰的成员内部类)

2. 局部内部类(不谈修饰符)、匿名内部类

注意：内部类其实日常开发中使用并不是非常多，大家在看一些库中的代码时候可能会遇到的比较多，日常开始中使用最多的是匿名内部类。

成员内部类

在外部类中，内部类定义位置与外部类成员所处的位置相同，因此称为成员内部类

普通内部类

未被static修饰的成员内部类


public class OutClass {
    private int a;
    static int b;
    int c;
    public void methodA(){
        a = 10;
        System.out.println(a);
    } 
    p
ublic static void methodB(){
        System.out.println(b);
    } 
    /
/ 成员内部类：未被static修饰
    class InnerClass{
        int c;
        public void methodInner(){
        // 在内部类中可以直接访问外部类中：任意访问限定符修饰的成员
        a = 100;
        b =200;
        methodA();
        methodB();
        // 如果外部类和内部类中具有相同名称成员时，优先访问的是内部类自己的
        c = 300;
        System.out.println(c);
        // 如果要访问外部类同名成员时候，必须：外部类名称.this.同名成员名字
        OutClass.this.c = 400;
        System.out.println(OutClass.this.c);
    }
} 
    p
ublic static void main(String[] args) {
    // 外部类：对象创建 以及 成员访问
    OutClass outClass = new OutClass();
    System.out.println(outClass.a);
    System.out.println(OutClass.b);
    System.out.println(outClass.c);
    outClass.methodA();
    outClass.methodB();
    System.out.println("=============内部类的访问=============");
    // 要访问普通内部类中成员，必须要创建普通内部类的对象
    // 而普通内部类定义与外部类成员定义位置相同，因此创建普通内部类对象时必须借助外部类
    // 创建内部类对象
    OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();
    // 上述语法比较怪异，也可以先将外部类对象先创建出来，然后再创建内部类对象
    OutClass.InnerClass innerClass2 = outClass.new InnerClass();
    innerClass2.methodInner();
}

【注意事项】

1. 外部类中的任何成员都可以被在普通内部类方法中直接访问

2. 普通内部类所处的成员与外部类成员位置相同，因此也受public、private等访问限定符的约束

3. 在内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：

外部类名称.this. 同名成员来访问

4. 普通内部类对象必须在先有外部类对象前提下才能创建

5. 普通内部类的非静态方法中包含了一个指向外部类对象的引用

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

final 等价于 c++中的 const

静态内部类

不依赖于对象

被static修饰的内部成员类


p
ublic class OutClass {
    private int a;
    static int b;
    public void methodA(){
        a = 10;
        System.out.println(a);
    } 
    p
ublic static void methodB(){
        System.out.println(b);
    }
    /
/ 静态内部类：被static修饰的成员内部类
    static class InnerClass{
        public void methodInner(){
            // 在内部类中只能访问外部类的静态成员
            // a = 100; // 编译失败，因为a不是类成员变量
            b =200;
            // methodA(); // 编译失败，因为methodB()不是类成员方法
            methodB();
        }
    } 
    p
ublic static void main(String[] args) {
        // 静态内部类对象创建 & 成员访问
        OutClass.InnerClass innerClass = new OutClass.InnerClass();
        innerClass.methodInner();
    }
}

【注意事项】

1. 在内部类中只能访问外部类中的静态成员

2. 创建内部类对象时，不需要先创建外部类对象

3. 成员内部类，经过编译之后会生成独立的字节码文件，命名格式为：外部类名称$内部类名称

局部内部类

定义在外部类的方法体或者 { } 中，该种内部类只能在其定义的位置使用，一般使用的非常少，此处简单了解下语法格式


public class OutClass {
    int a = 10;
    public void method(){
        int b = 10;
        // 局部内部类：定义在方法体内部
        // 不能被public、static等访问限定符修饰
        class InnerClass{
            public void methodInnerClass(){
                System.out.println(a);
                System.out.println(b);
            }
        } 
        /
/ 只能在该方法体内部使用，其他位置都不能用
        InnerClass innerClass = new InnerClass();
        innerClass.methodInnerClass();
} 
    p
ublic static void main(String[] args) {
        // OutClass.InnerClass innerClass = null; 编译失败
    }
}

【注意事项】

1. 局部内部类只能在所定义的方法体内部使用

2. 不能被public、static等修饰符修饰

3. 编译器也有自己独立的字节码文件，命名格式：外部类名字$x内部类名字.class，x是一个整数。

4. 几乎不会使用

匿名内部类

接口详解

对象的打印

toString 方法


public class Student{
    属性;
    方法;
    public static void main(String[] args){
        Student stu=new Student();
        System.out.println(stu);    
    }
}
//结果
day20210829.Student@1b6d3586

若默认打印属性，重写 toString方法


public class Student{
    属性;
    方法;
    @Override
    public String toString(){
        return "["+name+","+age+"]";    
    }
    public static void main(String[] args){
        Student stu=new Student();
        System.out.println(stu);    
    }
}

原理：ctrl+左键

最难不过坚持!

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/神奇cpp/article/detail/1011139