图灵日记之java奇妙历险记--类和对象-Toy模板网

这篇具有很好参考价值的文章主要介绍了图灵日记之java奇妙历险记--类和对象。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

类的定义和使用

类的定义格式

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

class为定义类的关键字，ClassName为类的名字，{}中为类的主体。

class future {
    public int time;

    public void decreaseTime() {
        
    }
}

类名注意采用大驼峰定义
成员前写法统一为public
此处写的方法不带 static 关键字

注意事项：
1. 一般一个文件当中只定义一个类,方便后期维护
2. main方法所在的类一般要使用public修饰(注意：Eclipse默认会在public修饰的类中找main方法)

class future {
    public int _time;
    public static void main(String[] args) {
        System.out.println("1");
    }
    public void decreaseTime() {
    }
}

此处的类未被public修饰,依旧可以使用main方法
3. public修饰的类必须要和文件名相同
4. 不要轻易去修改public修饰的类的名称

类的实例化

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

    public static void main(String[] args) {
        future date1 = new future();
        future date2 = new future();
    }

图灵日记之java奇妙历险记--类和对象,java,java,类和对象
(地址随便给的)

当你创建一个类的实例时，实际上是在内存中分配了一块空间来存储这个实例，并返回一个指向该内存空间的引用。这个引用指示了对象在内存中的位置，而不是对象本身的内容。通过这个引用，你可以访问和操作对象的属性和方法。

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

类和对象的说明

类只是一种模板.类似于建筑图纸,实例化就是把图纸建造成高楼大厦
类是一种自定义类型,类可以实例化出多个对象,类似图纸可以修建很多大厦,实例化的对象占用实际的物理空间,存储成员变量,此处是普通成员变量,类的实例化会分配内存空间来存储对象的实例变量，并提供指向方法的引用，但静态成员变量和静态方法不会在实例化过程中分配新的空间

this引用

public class test {
    public static void main(String[] args) {
        stu a = new stu();
        stu b = new stu();
        a.InitStu(1,"ab",1);
        b.InitStu(2,"cd" ,2);
    }
}
class stu {
    public int age;
    public String name;
    public int index;
    public void InitStu(int age, String name, int index) {
    }
}

方法在类中是通过引用存在的,一个类创建的不同对象在调用同一个方法,而方法如何区分不同对象?

有宝子就很奇怪地会指出
图灵日记之java奇妙历险记--类和对象,java,java,类和对象
调用函数之前不是会有对象吗,这里还要再次重申一遍,方法在类中是以引用的形式存在的,方法不像成员变量,方法进行的是一种重复操作,没必要每次实例化对象还要额外开辟空间,只需要开辟一次,之后调用之时去调用引用来进行方法调用,那么对于同一个方法,编译器该如何区分呢?这里就要提到this引用了

图灵日记之java奇妙历险记--类和对象,java,java,类和对象

对象a和b都有自己的引用,在函数调用时,系统会默认把this引用一起传给方法.方法被调用时，this关键字将会引用调用该方法的对象，即a或b,来区分不同对象。

class stu {
    public int age;
    public String name;
    public int index;
    public void InitStu(int age, String name, int index) {
        age = age;
        name = name;
        index = index;
    }
}

对stu类里的InitStu方法进行如上操作,但是由于局部变量优先的原则,方法内的变量不会优先识别方法之外的变量,而是优先方法内的局部变量,方法内找不到才会到类中寻找,如上代码可以得出,方法里修改的是形参,未对类里的成员变量进行修改
图灵日记之java奇妙历险记--类和对象,java,java,类和对象

如果要对成语变量进行修改,使用this引用来指明,如下
图灵日记之java奇妙历险记--类和对象,java,java,类和对象

this引用的特性

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

对象的构造及初始化

    public static void main(String[] args) {
        int a;
        System.out.println(a);
    }

局部变量未初始化,打印会报错,但是如果是成员变量则不一样,成员变量未初始化在进行打印时不会报错,因为类的对象在申请空间之后依旧设置好了初始化值,如下
数据类型默认值
byte 0
char ‘\u0000’
short 0
int 0
long 0L
boolean false
float 0.0f
double 0.0
reference null

        stu a = new stu();
        System.out.println(a.index);
        System.out.println(a.age);
        System.out.println(a.name);

图灵日记之java奇妙历险记--类和对象,java,java,类和对象

就地初始化

在声明成员变量时，就直接给出了初始值

class stu {
    public int age = 1;
    public String name = null;
    public int index = 1;
    public void InitStu(int age, String name, int index) {
        this.age = age;
        this.name = name;
        this.index = index;
    }
}

图灵日记之java奇妙历险记--类和对象,java,java,类和对象

构造方法

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

对象的产生一是需要为对象分配内存,二是调用合适的构造方法,而刚才类里没有构造方法为什么对象会产生,那是因为系统在发现类里没有构造方法的情况下会自动生成一个构造方法,如下

    public class Animal {
        /*public Animal() {
        
        }系统默认生成这样的构造函数来进行调用*/
        String name;
        int age;
    }

但是在你依旧有构造方法的时候,系统就不会生成默认构造方法,防止冲突,如下代码就会报错,因为不会生成默认构造方法

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

public class test {
    public static void main(String[] args) {
        Animal pig = new Animal();
        System.out.println(pig.age);
        System.out.println(pig.name);
    }
}

你还可以在你定义的构造方法调用另一个自己的构造方法

class Animal {
    public Animal(String name, int age) {
        this.age = age;
        this.name = name;
    }
    public Animal() {
        this("pig",1);
    }
    public String name;
    public int age;
}

但是需要注意在public Animal() 中this(“pig”,1)只能当第一条语句,后面可以添加其他语句
不能成环

    public Animal(String name, int age) {
        this();
    }
    public Animal() {
        this("pig",1);
    }

递归套娃的感觉,反正成环就哒唛

封装

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

图灵日记之java奇妙历险记--类和对象,java,java,类和对象

public class things {
//这里把成员变量给密封在类里,外界无法访问
    private String name;
    private int year;
    private String color;

    public things() {

    }
    public things(String name, int year, String color) {
        this.name = name;
        this.year = year;
        this.color = color;
    }
    public void show() {
        System.out.println(this.color);
        System.out.println(this.year);
        System.out.println(this.name);
    }
}

public class test02 {
    public static void main(String[] args) {
        things book = new things("book",1,"red");
        book.show();
    }
}

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互
注意:这里的接口包括方法,也包括之后学的接口

包

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

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

导入包中的类

可以使用java.util.Arrays导入java.util包中的Arrays类

    public static void main(String[] args) {
        int[] arr = {1,2,3};
        System.out.println(java.util.Arrays.toString(arr));

    }

这样的写法比较麻烦,可以使用import语句导入包

import java.util.Arrays;
public class test03 {
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        System.out.println(Arrays.toString(arr));
    }
}

导入包时也可以使用import java.util.;.;
*是通配符,表示所有的意思,就是导入ijava.util所有的类
建议使用显式的指定要导入的类名,否则会出现冲突

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

图灵日记之java奇妙历险记--类和对象,java,java,类和对象
静态方法

    public static void main(String[] args) {
        int[] arr = {2,33,3};
        sort(arr);//可以直接写方法
        for (int x:arr) {
            System.out.println(x+" ");
        }
    }

自定义包

基本规则

在文件的最上方加一个package语句指定该代码在哪个包中
包名需要尽量指定成唯一的名字,通常会用公司的域名颠倒形式
包名要和代码路径相匹配
如果一个类没有package语句,则该类被放到一个默认包

(子类要等到后面再展开)
先提一下default,他就是不加任何访问限定符的状态

上图创建一个A包,包里有B和C包,B包里有testB类,C包里有testC类

public class testC {
    int tem;//不加访问修饰限定符
    public int tem1;
}

图灵日记之java奇妙历险记--类和对象,java,java,类和对象
在另一个包B里实例化testC这个类,对象名叫a,上图可以看出我们可以访问tem1,但是default也就是不加访问限定符的情况下,无法访问tem这个变量

static成员

public class person {
    public int time;
    public String name;
}

定义person这个类,变量time对于每个person都一样的(前提),但是如果你每次实例化一个对象都要开辟空间给变量time,本来一个就够了,但是你每次都要开辟空间,就会造成空间浪费
如果time属性对于所有的person对象都是相同的，那么将其设置为static是合适的。这样，这个属性就不会与每个person对象实例关联，而是与类本身关联。这样，无论创建多少个person对象，都只会有一个time属性，所有对象都会共享这个属性

public class person {
    public static int time;
    public String name;
}

static修饰成员变量

静态成员变量在方法区中存储 ,被static修饰的只能是成员变量,不能是局部变量

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

不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
类变量存储在方法区当中
生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

static修饰成员方法

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

【静态方法特性】

不属于某个具体的对象，是类方法
可以通过对象调用，也可以通过类名.静态方法名(…)方式调用，更推荐使用后者
不能在静态方法中访问任何非静态成员变量
静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用

代码块

代码块概念及分类

使用{}定义一段代码称为代码段.根据代码块定义的位置以及关键字,又可分为以下四种

普通代码块(少见)
构造块
静态块
同步代码块(期待后续)

构造代码块

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

静态代码块

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量
注意事项
静态代码块不管生成多少个对象，其只会执行一次
静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)
实例代码块只有在创建对象时才会执行

public class test {
    public static void main(String[] args) {
        person tem1 = new person();
        System.out.println("================");
        person tem2 = new person();

    }
}
class person {
    public static int time;
    public String name;
    person() {
        System.out.println("构造方法");
        person.time = 1;
        this.name = "张三";
    }

    public void show() {
        System.out.println(this.name);
        System.out.println(person.time);
    }
    //静态代码块
    static {
        System.out.println("静态代码块");
    }
    //构造代码块
    {
        System.out.println("构造代码块");
    }
}

图灵日记之java奇妙历险记--类和对象,java,java,类和对象

匿名对象

举个栗子:

public class test {
    public static void main(String[] args) {
        String tem;
        System.out.println(tem);
    }
}

思维有些混淆的宝子会说不是有默认值吗,我们再说一下,是类里的成员变量在未初始化的时候会有默认值,tem是局部变量,需要初始化

类里的成员变量：
当你在类中声明一个变量，这个变量是类的成员变量。如果这些变量没有被初始化，它们会有默认值。例如，对于引用类型（如String），默认值是null。对于数值类型，默认值是相应的默认值（例如，int的默认值是0）。
局部变量：
局部变量是在方法内部声明的变量。它们只在方法的作用域内存在，并且没有默认值。在声明之后必须显式地初始化它们，否则编译器会报错。

public class test {
    String tem;
    public static void main(String[] args) {
        System.out.println(tem);//依旧报错
    }
}

有宝子又要说:这也不行啊,上面的代码main方法被static修饰,是个类方法,他的调用不依赖于对象,但是tem这个成员变量属于类,不能直接调用,因为静态的里面不能访问非静态的,如果你非要调用就给一个对象即可

public class test {
    String tem;
    public static void main(String[] args) {
        test a = new test();
        System.out.println(a.tem);
    }
}

public class test {
    String tem;
    public static void main(String[] args) {
        System.out.println(new test().tem);//匿名对象的方式
    }
}

匿名对象的缺点:
只能使用一次,不能重复使用

内部类

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

class Outer_classes {
    class Inner_classes {
        
    }
}

注意:

定义在class类名{}花括号外面,都不能称为内部类

class Outer_classes {

}
class Inner_classes {

}

//Outer_classes和Inner_classes是两个独立的类,彼此之间没有关系

内部类的分类

实例内部类

即未被static修饰成员内部类


public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.Print();
    }
}

class Outer {
    public int a = 1;
    public void Print() {
        System.out.println("Out");
    }
    class Inner {
        public int b = 2;
        public void Print() {
            System.out.println("in");
        }
    }
}

要实例化内部类,要先实例化外部类
内部类不能实现被static修饰的静态成员变量

    class Inner {
        public int b = 2;
        //此处会报错
        public static int c = 3;
        public void Print() {
            System.out.println("in");
        }
    }

如果内部类存在静态成员变量,那么就要以内部类的方式访问,但是要想访问内部类就要先实例化外部类产生对象
如果非要存在静态成员,可以用final修饰,成为常量,编译过程就确定了

        public static final int c = 3;

当实例内部类和外部类出现同名的成员变量的时候,优先实例内部类


public class Test {
    public static void main(String[] args) {
        Out out = new Out();
        Out.In in = out.new In();
        in.test();
    }
}


class Out {
    public int a = 1;
    class In {
        public int a = 0;
        public void test() {
            System.out.println(a);
        }
    }
}

图灵日记之java奇妙历险记--类和对象,java,java,类和对象
但如果你要在实例内部类里访问外部类
对刚才内部类里test方法进行如下操作来访问外部类的同名变量

        public void test() {
            System.out.println(Out.this.a);
        }

图灵日记之java奇妙历险记--类和对象,java,java,类和对象
实例内部类包含两个this

外部类访问实例内部类


public class Test {
    public static void main(String[] args) {
        Out out = new Out();
        Out.In in = out.new In();
        out.test();
    }
}

class Out {
    public int a = 1;
    class In {
        public int a = 0;
        public void test() {
            System.out.println(Out.this.a);
        }
    }
    public void test() {
        In in = new In();
        //访问内部类
        System.out.println(in.a);
    }
}

注意事项

外部类中的任何成员都可以在实例内部类方法中直接访问
实例内部类所处的位置与外部类成员位置相同,因此也受到public,private等访问限制符的约束
在实例内部类方法中访问同名的成员时,优先访问自己的,如果要访问外部类同名的成员,必须:外部类名称.this.同名成员来访问
实例化内部类对象必须在先有外部类对象前提下才能创建
实例内部类的非静态方法中包含一个指向外部类对象的引用
外部类中,不能直接访问实例内部类中的成员,如果要访问必须先要创建内部类的对象

静态内部类


public class Test {
    public static void main(String[] args) {
        Out.In in = new Out.In();
        in.test();
    }
}

class Out {
    public int a = 1;

    static class In {
        public int b = 2;
        public static int c = 3;
        public void test() {
            System.out.println("in");
        }
    }
    public void test() {
        System.out.println("out");
    }
}

图灵日记之java奇妙历险记--类和对象,java,java,类和对象
静态内部类访问外部类非静态成员变量要实例化外部类进行访问

public class Test {
    public static void main(String[] args) {
        Out.In in = new Out.In();
        in.test();
    }
}

class Out {
    public int a = 1;
    public static int d = 4;
    static class In {
        public int b = 2;
        public static int c = 3;
        public void test() {
        //实例化之后对a进行访问
            Out out = new Out();
            System.out.println(out.a);
            System.out.println(b);
            System.out.println(c);
            System.out.println(d);
        }
    }
    public void test() {
        System.out.println("out");
    }
}

注意

静态内部类只能访问外部类中的静态成员
创建静态内部类对象时,不需要先创建外部类对象

局部内部类

定义在外部类的方法题或者{}中,该种内部类只能在其定义的位置使用
注意

局部内部类只能在所定义的方法体内部使用
不能被public,static等修饰符修饰
编译器也有自己独立的字节码文件,命名格式:外部类名字$数字内部类名字.class
几乎不会使用

匿名内部类

public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal() {
            @Override
            public void eat() {
                System.out.println("eat");
            }
        };
        animal.eat();
    }
    public static void main00(String[] args) {
        Out.In in = new Out.In();
        in.test();
    }
}


interface Animal {
    void eat();
}

正常来说,无法实例化接口,但是使用匿名内部类来实现接口的方法后,可以进行实例化,也可以这样文章来源地址https://www.toymoban.com/news/detail-767188.html

        new Animal() {
            @Override
            public void eat() {
                System.out.println("eat");
            }
        }.eat();