Java类与对象

翻斗花园熊爷爷

已于 2023-10-31 21:03:37 修改

阅读量47

点赞数

分类专栏： Java学习文章标签：开发语言 intellij-idea

于 2023-10-31 21:02:59 首次发布

本文链接：https://blog.csdn.net/qq_42005321/article/details/134149212

版权

Java学习专栏收录该内容

8 篇文章 0 订阅

订阅专栏

Java类的定义及定义类时可用的关键字

public：表示“共有”的意思。如果使用 public 修饰，则可以被其他类和程序访问。每个 Java 程序的主类都必须是 public 类，作为公共工具供其他类和程序使用的类应定义为 public 类。
abstract：如果类被 abstract 修饰，则该类为抽象类，抽象类不能被实例化，但抽象类中可以有抽象方法（使用 abstract 修饰的方法）和具体方法（没有使用 abstract 修饰的方法）。继承该抽象类的所有子类都必须实现该抽象类中的所有抽象方法（除非子类也是抽象类）。
final：如果类被 final 修饰，则不允许被继承。
class：声明类的关键字。
class_name：类的名称。
extends：表示继承其他类。
implements：表示实现某些接口。

Java 类名的命名规则：

类名应该以下划线（_）或字母开头，最好以字母开头。
第一个字母最好大写，如果类名由多个单词组成，则每个单词的首字母最好都大写。
类名不能为 Java 中的关键字，例如 boolean、this、int 等。
类名不能包含任何嵌入的空格或点号以及除了下划线（_）和美元符号（$）字符之外的特殊字符

Java类的属性：成员变量的定义和声明

在 Java 中类的成员变量定义了类的属性。例如，一个学生类中一般需要有姓名、性别和年龄等属性，这时就需要定义姓名、性别和年龄 3 个属性。声明成员变量的语法如下：

[public|protected|private][static][final]<variable_name>

public、protected、private：用于表示成员变量的访问权限。
static：表示该成员变量为类变量，也称为静态变量。
final：表示将该成员变量声明为常量，其值无法更改。
type：表示变量的类型。
variable_name：表示变量名称

可以在声明成员变量的同时对其进行初始化，如果声明成员变量时没有对其初始化，则系统会使用默认值初始化成员变量。

public class Counter {
    static int sum;
    public static void main(String[] args) {
        System.out.println(sum);
    }
}
\\sum=0

Java创建一个学生类

Student.java

public class Student {

        public String Name;
        public int Age;
        private boolean Sex;
        public void setSex(boolean sex){this.Sex=sex;}
        public boolean getSex(){return Sex;}
    }


 Main.java

public class Main {

    public static void main(String[] args) {
    Student stu=new Student();
    stu.Name="xiongwenhao"; 
    stu.setSex(true);
    stu.Age=18;
    System.out.print("姓名：" + stu.Name + "\t性别：" + stu.getSex() + "\t年龄：" + stu.Age);


    }

Java成员方法的声明和调用

成员方法一旦被定义，便可以在程序中多次调用，提高了编程效率。声明成员方法的语法格式如下：

public class Test {
    [public|private|protected][static]<void|return_type><method_name>([paramList]) {
        // 方法体
    }
}

method_name 表示自定义的方法名称，方法的名称首先要遵循标识符的命名约定，除此之外，方法的名称第一个单词的第一个字母是小写，第二单词的第一个字母是大写，依此类推。

paramList 表示参数列表，这些变量都要有自己的数据类型，可以是原始数据类型，也可以是复杂数据类型，一个方法主要依靠参数来传递消息。方法主体是方法中执行功能操作的语句。其他各修饰符的含义如下。

public、private、protected：表示成员方法的访问权限。
static：表示限定该成员方法为静态方法。
final：表示限定该成员方法不能被重写或重载。
abstract：表示限定该成员方法为抽象方法。抽象方法不提供具体的实现，并且所属类型必须为抽象类。

Student.java

public class Student {

        public String Name;
        public int Age;
        private boolean Sex;
        public void setSex(boolean sex){this.Sex=sex;}
        public boolean getSex(){return Sex;}
        
 public StringBuffer printInfo(Student st){
                StringBuffer sb=new StringBuffer();
                sb.append("学生姓名："+st.Name+"\n 学生年龄："+st.Age);
                return  sb;


    }


 Main.java

public class Main {

    public static void main(String[] args) {
    Student stu=new Student();
    stu.Name="xiongwenhao"; 
    stu.setSex(true);
    stu.Age=18;
    System.out.print("姓名：" + stu.Name + "\t性别：" + stu.getSex() + "\t年龄：" + stu.Age);


    }

Java this关键字详解（3种用法）

this 关键字是 Java 常用的关键字，可用于任何实例方法内指向当前对象，也可指向对其调用当前方法的对象，或者在需要当前类型对象引用时使用。

this.属性名

public class Teacher {
    private String name;
    private double salary;
    private int age;
    public Teacher(String name,double salary,int age){
        this.name=name;
        this.age=age;
        this.salary=salary;
    }

    public String getName() {
        return name;
    }

    public double getSalary() {
        return salary;
    }

    public int getAge() {
        return age;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
      this.age = age;
    }
}



public class Main {

    public static void main(String[] args) {

Teacher teacher = new Teacher("XIONG Wenhao",30000.0,20);
System.out.print("Name: "+teacher.getName()+"\t salary: "
        +teacher.getSalary()+"\t Age"+teacher.getAge());

    }
}

this.方法名

this 关键字最大的作用就是让类中一个方法，访问该类里的另一个方法或实例变量。

public class Dog
{
    public void jump(){
        System.out.println("JUMP.........");
    }


    public void run(){
        Dog dog=new Dog();
        dog.jump();
        System.out.println("RUN............");
    }

    public void speedrun(){
        this.jump();
        System.out.println("speedrun......public class Main {



public static void main(String[] args) {

Dog dog=new Dog();
dog.run();
dog.speedrun();

    }
}
    }

}




JUMP.........
RUN............
JUMP.........
speedrun.......

在run方法中一个产生了两个对象，第一个实在main类中创建的，第二个实在Dog类中创建的。

1）在 run( ) 方法中调用 jump( ) 方法时是否一定需要一个 Dog 对象？

答案是肯定的，因为没有使用 static 修饰的成员变量和方法都必须使用对象来调用。

2）是否一定需要重新创建一个 Dog 对象？

不一定，因为当程序调用 run( ) 方法时，一定会提供一个 Dog 对象，这样就可以直接使用这个已经存在的 Dog 对象，而无须重新创建新的 Dog 对象了。因此需要在 run() 方法中获得调用该方法的对象，通过 this 关键字就可以满足这个要求。

this 可以代表任何对象，当 this 出现在某个方法体中时，它所代表的对象是不确定的，但它的类型是确定的，它所代表的只能是当前类的实例。只有当这个方法被调用时，它所代表的对象才被确定下来，谁在调用这个方法，this 就代表谁。

注意：对于 static 修饰的方法而言，可以使用类来直接调用该方法，如果在 static 修饰的方法中使用 this 关键字，则这个关键字就无法指向合适的对象。所以，static 修饰的方法中不能使用 this 引用。并且 Java 语法规定，静态成员不能直接访问非静态成员。
this( )访问构造方法

this( ) 用来访问本类的构造方法（构造方法是类的一种特殊方法，方法名称和类名相同，没有返回值。详细了解可参考《[Java构造方法一节】，括号中可以有参数，如果有参数就是调用指定的有参构造方法。

public class Test {
    String name;
    //int age;
    public Test(){
        this.name="zhang";

    }
    public Test(String name){this.name=name;}

    public void printInfo(){
        System.out.println(this.name);
    }
}

public class Main {
  public static void main(String[] args) {
Test test1=new Test("xiongwenhao");
Test test2=new Test();

test2.printInfo();
test1.printInfo();
    }
}

Java创建对象详解（显式创建和隐含创建）

对象是对类的实例化。对象具有状态和行为，变量用来表明对象的状态，方法表明对象所具有的行为。

1. 使用 new 关键字创建对象

类名对象名 = new 类名()；

隐含创建对象

除了显式创建对象以外，在 Java 程序中还可以隐含地创建对象，例如下面几种情况。

String strName = “strValue”，其中的“strValue”就是一个 String 对象，由 Java 虚拟机隐含地创建。

无论釆用哪种方式创建对象，Java 虚拟机在创建一个对象时都包含以下步骤：

给对象分配内存。
将对象的实例变量自动初始化为其变量类型的默认值。
初始化对象，给实例变量赋予正确的初始值。

注意：每个对象都是相互独立的，在内存中占有独立的内存地址，并且每个对象都具有自己的生命周期，当一个对象的生命周期结束时，对象就变成了垃圾，由 Java 虚拟机自带的垃圾回收机制处理。

深入解析Java的new关键字

在 Java 中 new 的操作往往意味着在内存中开辟新的空间，这个内存空间分配在内存的堆区。

堆是用来存放由 new 创建的对象和数组，即动态申请的内存都存放在堆区。

栈是用来存放在方法中定义的一些基本类型的变量和对象的引用变量。

classname obj = new classname( );

obj 是创建的对象，classname 是类的名字，类名后边的( )指明了类的构造方法。构造方法定义了当创建一个对象时要进行的操作。

    public class Test {
    public static void main(String[] args) {
        String a = "Java语言中文网";
        String b = new String("Java语言中文网");
        String c = "Java语言中文网";
        String d = new String("Java语言中文网");
        System.out.println(a == b);
        System.out.println(a == c);
        System.out.println(d == b);
        System.out.println(a);
        a = "Java";
        System.out.println(a);
    }
}

输出结果

false
true
false
Java语言中文网
Java

不同方式定义字符串时堆和栈的变化：

String a = "Java语言中文网";在栈中创建一个 String 类的对象引用变量 a，然后查找栈中有没有存放“Java语言中文网”，如果有则直接指向“Java语言中文网"，如果没有，则将”Java语言中文网“存放进栈，再指向。
String a = new String("Java语言中文网");不仅在栈中创建一个 String 类的对象引用变量 a，同时也在堆中开辟一块空间存放新建的 String 对象“Java语言中文网”，变量 a 指向堆中的新建的 String 对象”Java语言中文网“。

==用来比较两个对象在堆区存放的地址是否相同。根据上面的输出结果，我们可以看出：

使用 new 运算符创建的 String 对象进行==操作时，两个地址是不同的。这就说明，每次对象进行 new 操作后，系统都为我们开辟堆区空间，虽然值是一样，但是地址却是不一样的。
当我们没有使用 new 运算符的时候，系统会默认将这个变量保存在内存的栈区。如果变量的值存放在栈中，使用==比较时，比较的是具体的值。如果变量的值存放在堆中，使用==比较时，比较的是值所在的地址。因此在变量 a 与变量 c 进行==操作的时候，返回 true，因为变量 a 和变量 c 比较的是具体的值，即“C语言中文网”。
在改变变量 a 的值后（如 a = “Java”），再次输出时，我们发现输出的结果是”Java“。事实上原来的那个“Java语言中文网”在内存中并没有清除掉，而是在栈区的地址发生了改变，这次指向的是”Java“所在的地址。

注意：如果需要比较两个使用 new 创建的对象具体的值，则需要通过“equal()”方法去实现，这样才是比较引用类型变量具体值的正确方式。

这时，你可能想知道为什么对整数或字符这样的简单变量不使用 new 运算符。答案是 Java 的简单类型不是作为对象实现的。出于效率的考虑，它们是作为“常规”变量实现的。

对象有许多属性和方法，这使得 Java 对对象的处理不同于简单类型。Java 在处理对象和处理简单类型时开销不同，Java 能更高效地实现简单类型。当然，如果你希望完全使用对象类型，那么 Java 也提供了简单类型的对象版本，也就是包装类。

大家一定要明白，new 运算符是在运行期间为对象分配内存的，这使得内存的分配更加灵活和高效，你的程序在运行期间可以根据实际情况来合理地分配内存。但是，内存是有限的，因此 new 有可能由于内存不足而无法给一个对象分配内存。如果出现这种情况，就会发生运行时异常。

Java匿名对象

每次 new 都相当于开辟了一个新的对象，并开辟了一个新的物理内存空间。如果一个对象只需要使用唯一的一次，就可以使用匿名对象，匿名对象还可以作为实际参数传递。

匿名对象就是没有明确的给出名字的对象，是对象的一种简写形式。一般匿名对象只使用一次，而且匿名对象只在堆内存中开辟空间，而不存在栈内存的引用。

public class Test {
    String name;
    //int age;
    public Test(){
        this.name="zhang";

    }
    public Test(String name){this.name=name;}

    public void printInfo(){
        System.out.println(this.name);
    }
}

public class Main {

    public static void main(String[] args) {

    new Test("XIONG WENHAO").printInfo();
        //输出结果  XIONG WENHAO
    }
}

在以上程序的主方法中可以发现，直接使用了“new Test(“XIONG WENHAO”)”语句，这实际上就是一个匿名对象，与之前声明的对象不同，此处没有任何栈内存引用它，所以此对象使用一次之后就等待被 GC（垃圾收集机制）回收。

匿名对象在实际开发中基本都是作为其他类实例化对象的参数传递的，在后面的 Java 应用部分的很多地方都可以发现其用法，而且细心的读者可以发现，匿名对象实际上就是个堆内存空间，对象不管是匿名的还是非匿名的，都必须在开辟堆空间之后才可以使用。

Java访问对象的属性和行为

每个对象都有自己的属性和行为，这些属性和行为在类中体现为成员变量和成员方法，其中成员变量对应对象的属性，成员方法对应对象的行为。

要引用对象的属性和行为，需要使用点（.）操作符来访问。对象名在圆点左边，而成员变量或成员方法的名称在圆点的右边。语法格式如下：

对象名.属性(成员变量) // 访问对象的属性

对象名.成员方法名() // 访问对象的方法

例如，定义一个 Student 类，创建该类的对象 stu，再对该对象的属性赋值，代码如下：

Student stu = new Student(); // 创建 Student 类的对象 stu
stu.Name = “李子文”; // 调用stu对象的Name属性并赋值
stu.Sex = true; // 调用stu对象的Sex属性并赋值
stu.Age = 15; // 调用stu对象的Age属性并赋值

如果一个对象要被使用，则对象必须被实例化，如果一个对象没有被实例化而直接调用了对象中的属性或方法，如下代码所示：

Student stu = null;
stu.Name = “李子文”;
stu.Sex = true;
stu.Age = 15;

则程序运行时会出现以下异常：

Exception in thread “main” java.lang.NullPointerException

此异常是开发中最常见的异常，也会始终伴随着每位开发人员，使用了未实例化的对象则肯定会出现此异常。

Java对象的销毁

对象使用完之后需要对其进行清除。对象的清除是指释放对象占用的内存。在创建对象时，用户必须使用 new 操作符为对象分配内存。不过，在清除对象时，由系统自动进行内存回收，不需要用户额外处理。这也是语言的一大特色，某种程度上方便了程序员对内存的管理。

Java 语言的内存自动回收称为垃圾回收（Garbage Collection）机制，简称 GC。垃圾回收机制是指 JVM 用于释放那些不再使用的对象所占用的内存。

Java 语言并不要求 JVM 有 GC，也没有规定 GC 如何工作。不过常用的 JVM 都有 GC，而且大多数 GC 都使用类似的算法管理内存和执行回收操作。具体的垃圾回收实现策略有好多种，在此不再赘述

一个对象被当作垃圾回收的情况主要如下两种。

1）对象的引用超过其作用范围。

{
Object o = new Object(); // 对象o的作用范围，超过这个范围对象将被视为垃圾
}

2）对象被赋值为 null。

{
Object o = new Object();
o = null; // 对象被赋值为null将被视为垃圾
}

在 Java 的 Object 类中还提供了一个 protected 类型的 finalize() 方法，因此任何 Java 类都可以覆盖这个方法，在这个方法中进行释放对象所占有的相关资源的操作。

在 Java 虚拟机的堆区，每个对象都可能处于以下三种状态之一。

1）可触及状态：当一个对象被创建后，只要程序中还有引用变量引用它，那么它就始终处于可触及状态。

2）可复活状态：当程序不再有任何引用变量引用该对象时，该对象就进入可复活状态。在这个状态下，垃圾回收器会准备释放它所占用的内存，在释放之前，会调用它及其他处于可复活状态的对象的 finalize() 方法，这些 finalize() 方法有可能使该对象重新转到可触及状态。

3）不可触及状态：当 Java 虚拟机执行完所有可复活对象的 finalize() 方法后，如果这些方法都没有使该对象转到可触及状态，垃圾回收器才会真正回收它占用的内存。

注意：调用 System.gc() 或者 Runtime.gc() 方法也不能保证回收操作一定执行，它只是提高了 Java 垃圾回收器尽快回收垃圾的可能性。

Java中的空对象（null）是怎么回事？

Java 语言支持两种数据类型，分别是基本数据类型和引用数据类型，而 null 是一种特殊的引用数据类型。本节主要介绍 Java 空对象是什么及如何判断对象是否为空。

Student stu = new Student(); // 语句1
Student stu2; // 语句2
stu2 = new Student(); // 语句3

语句 1 先声明一个 Student 类型的变量 stu，然后利用 new 关键字为其创建实例。一步到位，定义了一个实例变量并同时赋值。
语句 2 是声明一个 Student 类型的变量 stu2，虽然从表述习惯上讲 stu2 是实例变量，但实际上此时 stu2
并未成为一个真正的实例，它仅仅只是一个变量名字。
语句 3 中的 stu2 才成为了一个 Student 实例，它指向了内存中的某块地址空间。
为了明确表示那些仅有名字而没有内存空间的变量的具体内容，Java 引入了关键字 null。 null 表示“空”的意思，是绝对意义上的空，这个空指的是不存在。

一个引用变量（当变量指向一个对象时，这个变量就被称为引用变量）没有通过 new 分配内存空间，这个对象就是空对象，Java 使用关键字 null 表示空对象。示例代码如下：

String str1; // 相当于 String str1= null;
// 输出null字符串
System.out.println(str1);
// 调用length()方法
int len = str1.length();

第 5 行代码不会发生编译错误，但是当代码运行到第 5 行时，系统会抛出空指针异常。这是因为调用 length() 方法时，str1 是空对象。程序员应该避免调用空对象的属性和方法。

产生空对象主要有以下两种可能性：

程序员自己忘记了实例化，所以程序员必须防止这种情况发生，应该仔细检查自己的代码，为自己创建的所有对象进行实例化并初始化。
空对象是其它地方传递过来的，需要通过判断对象是否为 null 进行避免。

Java用户修改密码

public class Member {

private String useName;
private String passWord;

    public Member(String useName, String passWord) {
        this.useName = useName;
        this.passWord = passWord;
    }

    public String getUseName() {
        return useName;
    }

    public void setUseName(String useName) {
        this.useName = useName;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }

    @Override
    public String toString() {
        return "Member{" +
                "useName='" + useName + '\'' +
                ", passWord='" + passWord + '\'' +
                '}';
    }




// Press Shift twice to open the Search Everywhere dialog and type `show whitespaces`,
// then press Enter. You can now see whitespace characters in your code.


import java.util.Scanner;

public class Main {

    public static void main(String[] args) {


        Member admin = new Member("admin","123456");
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入原密码：");
        String pwd=sc.next();
        if(pwd.equals(admin.getPassWord())){
            System.out.println("请输入新密码：");
            String newPWD=sc.next();
            admin.setPassWord(newPWD);
            System.out.println("----------------用户信息----------------\n"+admin);
        }
        else{
            System.out.println("输入的密码错误，无法进行修改！");
        }

    }
}

Java访问控制修饰符详解（public、 private、protected 和 friendly）

通过使用访问控制修饰符来限制对对象私有属性的访问，可以获得 3 个重要的好处。

防止对封装数据的未授权访问。
有助于保证数据完整性。
当类的私有实现细节必须改变时，可以限制发生在整个应用程序中的“连锁反应”

1. private

用 private 修饰的类成员，只能被该类自身的方法访问和修改，而不能被任何其他类（包括该类的子类）访问和引用。因此，private 修饰符具有最高的保护级别。例如，设 PhoneCard 是电话卡类，电话卡都有密码，因此该类有一个密码域，可以把该类的密码域声明为私有成员。

2. friendly（默认）

如果一个类没有访问控制符，说明它具有默认的访问控制特性。这种默认的访问控制权规定，该类只能被同一个包中的类访问和引用，而不能被其他包中的类使用，即使其他包中有该类的子类。这种访问特性又称为包访问性（package private）。

同样，类内的成员如果没有访问控制符，也说明它们具有包访问性，或称为友元（friend）。定义在同一个文件夹中的所有类属于一个包，所以前面的程序要把用户自定义的类放在同一个文件夹中（Java 项目默认的包），以便不加修饰符也能运行。

3. protected

用保护访问控制符 protected 修饰的类成员可以被三种类所访问：该类自身、与它在同一个包中的其他类以及在其他包中的该类的子类。使用 protected 修饰符的主要作用，是允许其他包中它的子类来访问父类的特定属性和方法，否则可以使用默认访问控制符。

4. public

当一个类被声明为 public 时，它就具有了被其他包中的类访问的可能性，只要包中的其他类在程序中使用 import 语句引入 public 类，就可以访问和引用这个类。

类中被设定为 public 的方法是这个类对外的接口部分，避免了程序的其他部分直接去操作类内的数据，实际就是数据封装思想的体现。每个 Java 程序的主类都必须是 public 类，也是基于相同的原因。

Java static关键字（静态变量和静态方法）

在类中，使用 static 修饰符修饰的属性（成员变量）称为静态变量，也可以称为类变量，常量称为静态常量，方法称为静态方法或类方法，它们统称为静态成员，归整个类所有。

静态成员不依赖于类的特定实例，被类的所有实例共享，就是说 static 修饰的方法或者变量不需要依赖于对象来进行访问，只要这个类被加载，Java 虚拟机就可以根据类名找到它们。

调用静态成员的语法形式如下：

类名.静态成员

public class Member {
static int A=10;}

注意：

static 修饰的成员变量和方法，从属于类。
普通变量和方法从属于对象。
静态方法不能调用非静态成员，编译会报错。

静态变量

类的成员变量可以分为以下两种：

静态变量（或称为类变量），指被 static 修饰的成员变量。
实例变量，指没有被 static 修饰的成员变量。

1）静态变量

运行时，Java 虚拟机只为静态变量分配一次内存，在加载类的过程中完成静态变量的内存分配。
在类的内部，可以在任何方法内直接访问静态变量。
在其他类中，可以通过类名访问该类中的静态变量。

2）实例变量

每创建一个实例，Java 虚拟机就会为实例变量分配一次内存。
在类的内部，可以在非静态方法中直接访问实例变量。
在本类的静态方法或其他类中则需要通过类的实例对象进行访问。

静态变量在类中的作用如下：

静态变量可以被类的所有实例共享，因此静态变量可以作为实例之间的共享数据，增加实例之间的交互性。
如果类的所有实例都包含一个相同的常量属性，则可以把这个属性定义为静态常量类型，从而节省内存空间。例如，在类中定义一个静态常量 PI=3.14159256。

public static String str1="hello";
    public static void main(String[] args) {
    String str2=" World!";
        // 直接访问str1
    String acVar1=str1+str2;
    System.out.println(acVar1);

        // 通过类名访问str1
        String acVar2=Main.str1+str2;
        System.out.println(acVar2);
        //通过对象访问str1
        Main m=new Main();
        String Var3=m.str1+str2;
        System.out.println(Var3);

输出结果都是hello world！

静态方法

与成员变量类似，成员方法也可以分为以下两种：

静态方法（或称为类方法），指被 static 修饰的成员方法。
实例方法，指没有被 static 修饰的成员方法。

静态方法与实例方法的区别如下：

静态方法不需要通过它所属的类的任何实例就可以被调用，因此在静态方法中不能使用 this 关键字，也不能直接访问所属类的实例变量和实例方法，但是可以直接访问所属类的静态变量和静态方法。另外，和 this 关键字一样，super 关键字也与类的特定实例相关，所以在静态方法中也不能使用 super 关键字。
在实例方法中可以直接访问所属类的静态变量、静态方法、实例变量和实例方法。

public class StaticMethod {
    public static int count = 1;    // 定义静态变量count
    public int method1() {    
        // 实例方法method1
        count++;    // 访问静态变量count并赋值
        System.out.println("在静态方法 method1()中的 count="+count);    // 打印count
        return count;
    }
    public static int method2() {    
        // 静态方法method2
        count += count;    // 访问静态变量count并赋值
        System.out.println("在静态方法 method2()中的 count="+count);    // 打印count
        return count;
    }
    public static void PrintCount() {    
        // 静态方法PrintCount
        count += 2;
        System.out.println("在静态方法 PrintCount()中的 count="+count);    // 打印count
    }
    public static void main(String[] args) {
        StaticMethod sft = new StaticMethod();
        // 通过实例对象调用实例方法
        System.out.println("method1() 方法返回值 intro1="+sft.method1());
        // 直接调用静态方法
        System.out.println("method2() 方法返回值 intro1="+method2());
        // 通过类名调用静态方法，打印 count
        StaticMethod.PrintCount();
    }
返回值：
在静态方法 method1()中的 count=2
method1() 方法返回值 intro1=2
在静态方法 method2()中的 count=4
method2() 方法返回值 intro1=4
在静态方法 PrintCount()中的 count=6

在该程序中，静态变量 count 作为实例之间的共享数据，因此在不同的方法中调用 count，值是不一样的。从该程序中可以看出，在静态方法 method1() 和 PrintCount() 中是不可以调用非静态方法 method1() 的，而在 method1() 方法中可以调用静态方法 method2() 和 PrintCount()。

在访问非静态方法时，需要通过实例对象来访问，而在访问静态方法时，可以直接访问，也可以通过类名来访问，还可以通过实例化对象来访问。

静态代码块指 Java 类中的 static{ } 代码块，主要用于初始化类，为类的静态变量赋初始值，提升程序性能。

静态代码块的特点如下：

静态代码块类似于一个方法，但它不可以存在于任何方法体中。
静态代码块可以置于类中的任何地方，类中可以有多个静态初始化块。
Java 虚拟机在加载类时执行静态代码块，所以很多时候会将一些只需要进行一次的初始化操作都放在 static 代码块中进行。
如果类中包含多个静态代码块，则 Java 虚拟机将按它们在类中出现的顺序依次执行它们，每个静态代码块只会被执行一次。
静态代码块与静态方法一样，不能直接访问类的实例变量和实例方法，而需要通过类的实例对象来访问。

public class StaticCode {
    public static int count = 0;
    {
        count++;
        System.out.println("非静态代码块 count=" + count);
    }
    static {
        count++;
        System.out.println("静态代码块1 count=" + count);
    }
    static {
        count++;
        System.out.println("静态代码块2 count=" + count);
    }
    public static void main(String[] args) {
        System.out.println("*************** StaticCode1 执行 ***************");
        StaticCode sct1 = new StaticCode();
        System.out.println("*************** StaticCode2 执行 ***************");
        StaticCode sct2 = new StaticCode();
    }
}

静态代码块1 count=1
静态代码块2 count=2
*************** StaticCode1 执行 ***************
非静态代码块 count=3
*************** StaticCode2 执行 ***************
非静态代码块 count=4

Java import static静态导入

静态导入使用 import static 语句，静态导入也有两种语法，分别用于导入指定类的单个静态成员变量、方法和全部静态成员变量、方法，其中导入指定类的单个静态成员变量、方法的语法格式如下：

import static package.ClassName.fieldName|methodName;

导入指定类的全部静态成员变量、方法的语法格式如下：

import static package.ClassName.*;

import static java.lang.System.*;
import static java.lang.Math.*;
public class StaticImportTest {
    public static void main(String[] args) {
        // out是java.lang.System类的静态成员变量，代表标准输出
        // PI是java.lang.Math类的静态成员变量，表示π常量
        out.println(PI);
        // 直接调用Math类的sqrt静态方法，返回256的正平方根
        out.println(sqrt(256));
    }

static的常见问题和使用误区

1）为什么要用”static“关键字？
通常来说，用 new 创建类的对象时，数据存储空间才被分配，方法才供外界调用。有时候我们只想为特定域分配单一存储空间，不考虑要创建多少对象或者说根本就不创建任何对象，有时候我们想在没有创建对象的情况下也想调用方法。在这两种情况下，static 关键字，满足了我们的需求。

2）”static“关键字是什么意思？Java 中是否可以覆盖（子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写，又称为方法覆盖。这里了解即可，教程后面我们会详细讲解）一个 private 或者是 static 的方法？
“static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问。

Java 中 static 方法不能被覆盖，因为方法覆盖是基于运行时动态绑定的，而 static 方法是编译时静态绑定的。static 方法跟类的任何实例都不相关，所以概念上不适用。

3）是否可以在 static 环境中访问非 static 变量？
static 变量在 Java 中是属于类的，它在所有的实例中的值是一样的。当类被 Java 虚拟机载入的时候，会对 static 变量进行初始化。如果你的代码尝试不用实例来访问非 static 的变量，编译器会报错，因为这些变量还没有被创建出来，还没有跟任何实例关联上。

4）static 静态方法能不能引用非静态资源？
不能，new 的时候才会产生的东西，对于初始化后就存在的静态资源来说，不能引用它。

5）static 静态方法里面能不能引用静态资源？
可以，因为都是类初始化的时候加载的。

6）非静态方法里面能不能引用静态资源？
可以，非静态方法就是实例方法，那是 new 之后才产生的，那么属于类的内容它都认识。

1）static 关键字会改变类中成员的访问权限吗？

Java 中的 static 关键字不会影响到变量或者方法的作用域。在 Java 中能够影响到访问权限的只有 private、public、protected、friendly 这几个关键字

2）能通过 this 访问静态成员变量吗？

虽然对于静态方法来说没有 this，那么在非静态方法中能够通过 this 访问静态成员变量吗？先看下面的一个例子，这段代码输出的结果是什么？

public class Main {
    static int value = 33;
    public static void main(String[] args) throws Exception {
        new Main().printValue();
    }
    private void printValue() {
        int value = 3;
        System.out.println(this.value);    // 输出 33
    }
}

这里面主要考察 this 和 static 的理解。this 代表什么？this 代表当前对象，那么通过 new Main() 来调用 printValue 的话，当前对象就是通过 new Main() 生成的对象。而 static 变量是被对象所享有的，因此在 printValue 中的 this.value 的值毫无疑问是 33。在 printValue 方法内部的 value 是局部变量，根本不可能与 this 关联，所以输出结果是 33。在这里永远要记住一点：静态成员变量虽然独立于对象，但是不代表不可以通过对象去访问，所有的静态方法和静态变量都可以通过对象访问（只要访问权限足够）。

3）static 能作用于局部变量么？

Java 语法规定 static 是不允许用来修饰局部变量。

Java final修饰符详解

使用 final 关键字声明类、变量和方法需要注意以下几点：

final 用在变量的前面表示变量的值不可以改变，此时该变量可以被称为常量。
final 用在方法的前面表示方法不可以被重写（子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写，又称为方法覆盖。这里了解即可，教程后面我们会详细讲解）。
final 用在类的前面表示该类不能有子类，即该类不可以被继承

final 修饰的变量即成为常量，只能赋值一次，但是 final 所修饰局部变量和成员变量有所不同。

final 修饰的局部变量必须使用之前被赋值一次才能使用。
final 修饰的成员变量在声明时没有赋值的叫“空白 final 变量”。空白 final 变量必须在构造方法或静态代码块中初始化。

final 修饰基本类型变量和引用类型变量的区别

当使用 final 修饰基本类型变量时，不能对基本类型变量重新赋值，因此基本类型变量不能被改变。但对于引用类型变量而言，它保存的仅仅是一个引用，final 只保证这个引用类型变量所引用的地址不会改变，即一直引用同一个对象，但这个对象完全可以发生改变。

import java.util.Arrays;

class Person {
    private int age;

    public Person() {
    }

    // 有参数的构造器
    public Person(int age) {
        this.age = age;
    }
    // 省略age的setter和getter方法
    // age 的 setter 和 getter 方法
}

public class FinalReferenceTest {
    public static void main(String[] args) {
        // final修饰数组变量，iArr是一个引用变量
        final int[] iArr = { 5, 6, 12, 9 };
        System.out.println(Arrays.toString(iArr));
        // 对数组元素进行排序，合法
        Arrays.sort(iArr);
        System.out.println(Arrays.toString(iArr));
        // 对数组元素赋值，合法
        iArr[2] = -8;
        System.out.println(Arrays.toString(iArr));
        // 下面语句对iArr重新赋值,非法
        // iArr = null;
        // final修饰Person变量，p是一个引用变量
        final Person p = new Person(45);
        // 改变Person对象的age实例变量，合法
        p.setAge(23);
        System.out.println(p.getAge());
        // 下面语句对P重新赋值，非法
        // p = null;
    }
}

注意：在使用 final 声明变量时，要求全部的字母大写，如 SEX，这点在开发中是非常重要的。

public static final String SEX= “女”;
final修饰方法

final 修饰的方法不可被重写，如果出于某些原因，不希望子类重写父类的某个方法，则可以使用 final 修饰该方法。

对于一个 private 方法，因为它仅在当前类中可见，其子类无法访问该方法，所以子类无法重写该方法——如果子类中定义一个与父类 private 方法有相同方法名、相同形参列表、相同返回值类型的方法，也不是方法重写，只是重新定义了一个新方法。因此，即使使用 final 修饰一个 private 访问权限的方法，依然可以在其子类中定义与该方法具有相同方法名、相同形参列表、相同返回值类型的方法。这里仅限于private修饰的，public不行。

final 修饰的方法仅仅是不能被重写，并不是不能被重载，因此下面程序完全没有问题

public class FinalOverload {
    // final 修饰的方法只是不能被重写，完全可以被重载
    public final void test(){}
    public final void test(String arg){}
}

final修饰类

final 修饰的类不能被继承。当子类继承父类时，将可以访问到父类内部数据，并可通过重写父类方法来改变父类方法的实现细节，这可能导致一些不安全的因素。为了保证某个类不可被继承，则可以使用 final 修饰这个类。

Java main()方法

使用 main() 方法时应该注意如下几点：

访问控制权限是公有的（public）。
main() 方法是静态的。如果要在 main() 方法中调用本类中的其他方法，则该方法也必须是静态的，否则需要先创建本类的实例对象，然后再通过对象调用成员方法。
main() 方法没有返回值，只能使用 void。
main() 方法具有一个字符串数组参数，用来接收执行 Java 程序的命令行参数。命令行参数作为字符串，按照顺序依次对应字符串数组中的元素。
字符串中数组的名字（代码中的 args）可以任意设置，但是根据习惯，这个字符串数组的名字一般和 Java 规范范例中 main() 参数名保持一致，命名为 args，而方法中的其他内容都是固定不变的。
main() 方法定义必须是“public static void main(String[] 字符串数组参数名)”。
一个类只能有一个 main() 方法，这是一个常用于对类进行单元测试（对软件中的最小可测试单元进行检查和验证）的技巧。

Java方法的可变参数

声明可变参数的语法格式如下：

methodName({paramList},paramType…paramName)

例如：public static void print(String…name)

其中，methodName 表示方法名称；paramList 表示方法的固定参数列表；paramType 表示可变参数的类型；… 是声明可变参数的标识；paramName 表示可变参数名称。

public class Main {
    public static String str1="hello";
    public static void main(String[] args)
{
Main.print("Test","wo","shi","shui","hah");

    }
    public static void print(String...name){
        int cnt= name.length;
        System.out.println("本次参加考试的有"+cnt+"人，名单如下：");
        for(int i=0;i<cnt;i++){

            System.out.println(name[i]);
        }
    }
}

Java构造方法

构造方法是类的一种特殊方法，用来初始化类的一个新的对象，在创建对象（new 运算符）之后自动调用。java 中的每个类都有一个默认的构造方法，并且可以有一个以上的构造方法。

Java 构造方法有以下特点：

方法名必须与类名相同
可以有 0 个、1 个或多个参数
没有任何返回值，包括 void
默认返回类型就是对象类型本身
只能与 new 运算符结合使用

值得注意的是，如果为构造方法定义了返回值类型或使用 void 声明构造方法没有返回值，编译时不会出错，但 Java 会把这个所谓的构造方法当成普通方法来处理。不要在构造方法里使用 return 来返回当前类的对象，因为构造方法的返回值是隐式的。

构造方法不能被 static、final、synchronized、abstract 和 native（类似于 abstract）修饰。构造方法用于初始化一个新对象，所以用 static 修饰没有意义。构造方法不能被子类继承，所以用 final 和 abstract 修饰没有意义。多个线程不会同时创建内存地址相同的同一个对象，所以用 synchronized 修饰没有必要。如果不了解除 static、final 之外其他的关键字。

public class MyClass {
    private int m;    // 定义私有变量
    MyClass() {
        // 定义无参的构造方法
        m = 0;
    }
    MyClass(int m) {
        // 定义有参的构造方法
        this.m = m;
    }
}

该示例定义了两个构造方法，分别是无参构造方法和有参构造方法。在一个类中定义多个具有不同参数的同名方法，这就是方法的重载。这两个构造方法的名称都与类名相同，均为 MyClass。在实例化该类时可以调用不同的构造方法进行初始化。


public class Worker {
    public String name;
    private int age;
    public Worker(String name){
        this.name=name;
    }
    public Worker(String name,int age){
        this.name=name;
        this.age=age;
    }

    @Override
    public String toString() {
        return "Worker{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }}

//Main class

Worker worker=new Worker("TOM");
Worker worker1=new Worker("XIONGWENHAO",18);
System.out.println(worker.toString());
System.out.println(worker1.toString());

在 Worker 类中定义了两个属性，其中 name 属性不可改变。分别定义了带有一个参数和带有两个参数的构造方法，并对其属性进行初始化。最后定义了该类的 toString() 方法，返回一条新进员工的介绍语句。

提示：Object 类具有一个 toString() 方法，该方法是个特殊的方法，创建的每个类都会继承该方法，它返回一个 String 类型的字符串。如果一个类中定义了该方法，则在调用该类对象时，将会自动调用该类对象的 toString() 方法返回一个字符串，然后使用“System.out.println(对象名)”就可以将返回的字符串内容打印出来。

Java查询个人信息

public class Main {
    public static void main(String[] args) {
        Person person = new Person("王洁",21,"女","2016-02-21","狮子座");
        String intro = person.intro();
        System.out.println(intro);
    }}

public class Person {
private String name;
private int age;
private String sex;
private String birthday;
private String tell;
public Person(String name,int age,String sex,String birthday,String tell){
    this.name = name;
    this.age = age;
    this.sex = sex;
    this.birthday = birthday;
    this.tell = tell;

}
    public String intro() {
        return"姓名："+name+"\n年龄："+age+"\n性别："+sex+"\n出生日期："+birthday+"\n星痤："+tell;
    }
}

Java析构方法

析构方法与构造方法相反，当对象脱离其作用域时（例如对象所在的方法已调用完毕），系统自动执行析构方法。析构方法往往用来做清理垃圾碎片的工作，例如在建立对象时用 new 开辟了一片内存空间，应退出前在析构方法中将其释放。

在 Java 的 Object 类中还提供了一个 protected 类型的 finalize() 方法，因此任何 Java 类都可以覆盖这个方法，在这个方法中进行释放对象所占有的相关资源的操作。 (finalize已经被弃用，了解即可)

对象的 finalize() 方法具有如下特点：

垃圾回收器是否会执行该方法以及何时执行该方法，都是不确定的。
finalize() 方法有可能使用对象复活，使对象恢复到可触及状态。
垃圾回收器在执行 finalize() 方法时，如果出现异常，垃圾回收器不会报告异常，程序继续正常运行。

Java包（package）详解

Java 引入了包（package）机制，提供了类的多层命名空间，用于解决类的命名冲突、类文件管理等问题。

包的 3 个作用如下：

区分相同名称的类。
能够较好地管理大量的类。
控制访问范围。

Java 中使用 package 语句定义包，package 语句应该放在源文件的第一行，在每个源文件中只能有一个包定义语句，并且 package 语句适用于所有类型（类、接口、枚举和注释）的文件。定义包语法格式如下：

package 包名;

Java 包的命名规则如下：

包名全部由小写字母（多个单词也全部小写）。
如果包名包含多个层次，每个层次用“.”分割。
包名一般由倒置的域名开头，比如 com.baidu，不要有 www。
自定义包不能 java 开头。

注意：如果在源文件中没有定义包，那么类、接口、枚举和注释类型文件将会被放进一个无名的包中，也称为默认包。在实际企业开发中，通常不会把类定义在默认包下。
包导入

如果使用不同包中的其它类，需要使用该类的全名（包名+类名）。代码如下：

example.Test test = new example.Test();

其中，example 是包名，Test 是包中的类名，test 是类的对象。

为了简化编程，Java 引入了 import 关键字，import 可以向某个 Java 文件中导入指定包层次下的某个类或全部类。import 语句位于 package 语句之后，类定义之前。一个 Java 源文件只能包含一个 package 语句，但可以包含多个 import 语句。

使用 import 导入单个类的语法格式如下：

import 包名+类名;

上面语句用于直接导入指定类，例如导入前面的 example.Test 类，代码如下：

import example.Test;

使用 import 语句导入指定包下全部类的用法按如下：

import example.*;

上面 import 语句中的星号（*）只能代表类，不能代表包，表明导入 example 包下的所有类。

提示：使用星号（*）可能会增加编译时间，特别是引入多个大包时，所以明确的导入你想要用到的类是一个好方法，需要注意的是使用星号对运行时间和类的大小没有影响。

通过使用 import 语句可以简化编程，但 import 语句并不是必需的，如果在类里使用其它类的全名，可以不使用 import 语句。

Java 默认为所有源文件导入 java.lang 包下的所有类，因此前面在 Java 程序中使用 String、System 类时都无须使用 import 语句来导入这些类。但对于前面介绍数组时提到的 Arrays 类，其位于 java.util 包下，则必须使用 import 语句来导入该类。

在一些极端的情况下，import 语句也帮不了我们，此时只能在源文件中使用类全名。例如，需要在程序中使用 java.sql 包下的类，也需要使用 java.util 包下的类，则可以使用如下两行 import 语句：

import java.util.*;
import java.sql.*;

Java使用自定义包


import com.test.Xiong;

public class Main {
    public static void main(String[] args) {
        System.out.println("学生信息如下：");
    for(int var:Xiong.GetAll()){
        System.out.println(var);
    } }}

package com.test;

public class Xiong {
    public static int[] GetAll(){

        int[] all=new int[]{1,2,3,4,5};
        return all;
    }

}

Java递归算法

程序调用自身的编程技巧称为递归（recursion），它做为一种算法在程序设计语言中广泛应用。Java 支持递归，在 Java 编程中，递归是允许方法调用自身调用的属性。调用自身的方法称为是递归的。

public class Main {
    public static void main(String[] args) {
      Fib f=new Fib();
      System.out.println(f.fact(3));
  }}

public class Fib {
    int fact(int n){
        int res;
        if(n==1)
        {return 1;}
        res=fact(n-1)*n;
        return res;
    }
}

翻斗花园熊爷爷

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java类与对象

public：表示“共有”的意思。如果使用 public 修饰，则可以被其他类和程序访问。每个 Java 程序的主类都必须是 public 类，作为公共工具供其他类和程序使用的类应定义为 public 类。abstract：如果类被 abstract 修饰，则该类为抽象类，抽象类不能被实例化，但抽象类中可以有抽象方法（使用 abstract 修饰的方法）和具体方法（没有使用 abstract 修饰的方法）。继承该抽象类的所有子类都必须实现该抽象类中的所有抽象方法（除非子类也是抽象类）。final。
复制链接

扫一扫