【Java 类和对象】

类

package com.yuzhenc.oop;

/**
 * @author: yuzhenc
 * @date: 2022-02-22 20:29:28
 * @desc: com.yuzhenc.oop
 * @version: 1.0
 */
public class Person {
    //属性，也叫成员变量，放在类中方法外
    String name;//名字
    int age;//年龄
    double height;//身高
    double weight;//体重

    //方法，行为
    //睡觉
    public void sleep(){
        System.out.println("我在睡觉！");
    }

    //吃饭
    public void eat(){
        System.out.println("我在吃饭！");
    }
}

对象

package com.yuzhenc.oop;

/**
 * @author: yuzhenc
 * @date: 2022-02-22 20:36:32
 * @desc: com.yuzhenc.oop
 * @version: 1.0
 */
public class Test01 {
    public static void main(String[] args) {
        //创建一个Person类的对象（实例）
        Person p = new Person();
        //这个人的名字叫做sqlboy
        p.name = "sqlboy";
        //年龄25
        p.age = 25;
        //身高178
        p.height = 178;
        //体重145
        p.weight = 145;

        //sqlboy开始吃饭
        p.eat();
        //sqlboy开始睡觉
        p.sleep();
    }
}

局部变量和成员变量

• 区别

区别类型	局部变量	成员变量
代码中位置不同	方法中定义的变量，代码块中定义的变量	类中方法外定义的变量
代码作用范围不同	当前一个方法或者当前所在代码块	当前类的很多方法
是否有默认值	没有默认值	有默认值
是否要初始化	必须初始化，不然报错	不需要，建议使用时赋值即可
内存中的位置不同	栈内存	堆内存
作用时间不同	当前方法或当前代码块从开始执行到执行完毕	当前对象从创建到销毁

• 成员变量默认值

类型大类	类型小类	默认值
基本类型	byte	(byte)0
基本类型	short	(short)0
基本类型	int	0
基本类型	long	0L
基本类型	float	0.0f
基本类型	double	0.0d
基本类型	char	‘\u0000’ (null)
基本类型	boolean	false
引用类型	/	null

package com.yuzhenc.oop;

/**
 * @author: yuzhenc
 * @date: 2022-02-22 21:00:34
 * @desc: com.yuzhenc.oop
 * @version: 1.0
 */
public class Test02 {
    //定义成员变量，不进行初始化，则会使用默认值
    byte a;
    short b;
    int c;
    long d;
    float e;
    double f;
    char g;
    boolean h;
    Object i;

    public static void main(String[] args) {
        //创建Test02的对象
        Test02 t = new Test02();
        //调用t的print方法进行打印
        t.print();
    }
    //打印
    public void print(){
        System.out.println(a+"\t"+b+"\t"+"\t"+c+"\t"+d+"\t"+e+"\t"+f+"\t"+g+"\t"+h+"\t"+i);
    }
}

构造器

package com.yuzhenc.oop;

/**
 * @author: yuzhenc
 * @date: 2022-02-22 21:10:41
 * @desc: com.yuzhenc.oop
 * @version: 1.0
 */
public class Person1 {
    //定义属性
    String name;
    int age;
    //空构造器，缺省的构造器
    //当有其他重载构造器时，不显示写出这个构造器，则该无参构造器不存在
    public Person1(){};

    //构造器重载
    public Person1(String name, int age){
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {
        /*
            创建对象的过程：
            1.第一次遇到Person1的时候，进行类的加载（只加载1次）
            2.创建对象，为这个对象在堆中开辟空间
            3.为对象进行属性的初始化动作

            new关键字实际上是在调用一个方法，这个方法叫构造方法（构造器）
            调用构造器的时候，如果你的类中没有写构造器，那么系统会默认分配一个缺省的空构造器

            构造器和方法的区别：
            1.没有方法的返回值类型
            2.方法体内部不能有return语句
            3.构造器的名字很特殊，必须跟类名一致

            构造器的作用：不是为了创建对象，在调用构造器之前，对象已经创建好了，并且属性有
                默认的初始化的值，调用构造器是为了给属性进行赋值操作的

            注意：一般不在空构造器中进行初始化操作，因为那样的话，每个对象的属性就一样了
                我们只要保证空构造器存在就行了，里面不用写任何东西
        */

        Person1 p1 = new Person1("sqlboy", 25);
        System.out.println("我的名字叫"+p1.name+"!");//我的名字叫sqlboy!
        System.out.println("我今年"+p1.age+"岁了！");//我今年25岁了！
    }
}

this

package com.yuzhenc.oop;

/**
 * @author: yuzhenc
 * @date: 2022-02-22 21:34:03
 * @desc: com.yuzhenc.oop
 * @version: 1.0
 */
public class Person2 {
    String name;
    int age;

    public Person2(){}

    public Person2(String name, int age){
        this.name = name;//this指代当前对象
        this.age = age;//this指代当前对象
    }

    public void eat(){
        int age = 10;
        System.out.println(age);//就近原则，age指的是离它最近的age，局部变量age，所以输出10
        System.out.println(this.age);//当前对象的age，成员变量age
        System.out.println(name);//没有重名，直接是成员变量name
    }

    public void play(){
        /*this.*/eat();//同一类中的方法可以相互调用，this可以忽略不写
        System.out.println("吃完饭我要去玩了！");
    }

    public static void main(String[] args) {
        Person2 p2 = new Person2("sqlboy", 25);
        p2.play();
    }
}

static

package com.yuzhenc.oop;

/**
 * @author: yuzhenc
 * @date: 2022-02-22 21:59:47
 * @desc: com.yuzhenc.oop
 * @version: 1.0
 */
public class Person3 {
    String name;
    int age;
    //static修饰属性

    static int count;//直接类名可以调用

    //static修饰方法
    //static和public都是修饰符，并列的没有先后顺序，先写谁后写谁都行
    public static void print(){
        System.out.println("我是静态方法，直接类名就可以调用！");
    }

    public static void main(String[] args) {
        /*
            在类加载的时候，会将静态内容加载到方法区的静态域中，
            静态的内容先于对象的存在，这个静态内容被所有该类的对象共享
        */
        System.out.println(Person3.count);//0
        Person3.print();//我是静态方法，直接类名就可以调用！
    }
}

• 总结
  • 在类加载的时候一起加载入方法区中的静态域中
  • 先于对象存在
  • 访问方式： 对象名.属性名 类名.属性名（推荐）

代码块

• 类的组成：属性，方法，构造器，代码块，内部类
• 代码块分类：普通块，构造块，静态块，同步块（多线程）

package com.yuzhenc.oop;

/**
 * @author: yuzhenc
 * @date: 2022-02-22 22:14:54
 * @desc: com.yuzhenc.oop
 * @version: 1.0
 */
public class Test03 {
    //属性
    int a;
    static int sa;
    //方法
    public void a(){
        System.out.println("-----a");
        {
            //普通块限制了局部变量的作用范围
            System.out.println("这是普通块");
            System.out.println("----000000");
            int num = 10;
            System.out.println(num);
        }
        //System.out.println(num);
        //if(){}
        //while(){}
    }
    public static void b(){
        System.out.println("------b");
    }
    //构造块
    {
        System.out.println("------这是构造块");
    }
    //静态块
    static{
        System.out.println("-----这是静态块");
        //在静态块中只能方法：静态属性，静态方法
        System.out.println(sa);
        b();
    }
    //构造器
    public Test03(){
        System.out.println("这是空构造器");
    }
    public Test03(int a){
        this.a = a;
    }
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Test03 t = new Test03();
        t.a();
        Test03 t2 = new Test03();
        t2.a();
    }
}

• 代码块执行顺序
  • 最先执行静态块，只在类加载的时候执行一次，所以一般以后实战写项目：创建工厂，数据库的初始化信息都放入静态块，一般用于执行一些全局性的初始化操作
  • 再执行构造块（不常用）
  • 再执行构造器
  • 再执行方法中的普通块

包

• 包的作用：为了解决重名问题（实际上包对应的就是盘符上的目录）
• 包名定义
  • 名字全部小写
  • 中间用.隔开
  • 一般都是公司域名倒着写
  • 加上模块名字
  • 不能使用系统中的关键字
  • 包声明的位置一般都在非注释性代码的第一行
• 在导包以后，还想用其他包下同名的类，就必须要手动自己写所在的包

//声明包
package com.yuzhenc.oop;

import java.util.Date;//导包：就是为了进行定位

/**
 * @author: yuzhenc
 * @date: 2022-02-22 22:25:02
 * @desc: com.yuzhenc.oop
 * @version: 1.0
 */
public class Test04 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        new Person();
        new Date();
        new java.sql.Date(1000L);//在导包以后，还想用其他包下同名的类，就必须要手动自己写所在的包
        System.out.println(Math.random());//java.lang下的包可以直接使用
    }
}

• 总结
  • 使用不同包下的类要需要导包： import **..; 例如：import java.util.Date;
  • 在导包以后，还想用其他包下同名的类，就必须要手动自己写所在的包
  • 同一个包下的类想使用不需要导包，可以直接使用
  • 在java.lang包下的类，可以直接使用无需导包