【Java 类和对象】

package com.yuzhenc.oop;


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;


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();
    }
}

• 区别

• 成员变量默认值

package com.yuzhenc.oop;


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;


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) {
        

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

package com.yuzhenc.oop;


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(){
        eat();//同一类中的方法可以相互调用，this可以忽略不写
        System.out.println("吃完饭我要去玩了！");
    }

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

package com.yuzhenc.oop;


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;


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;//导包：就是为了进行定位


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包下的类，可以直接使用无需导包