Java面向对象1-引入概念

• OOA：面向对象分析Object Oriented Analysis
• OOD：面向对象设计Object Oriented Design
• OOP：面向对象编程Object Oriented Programming

创建类

• 类的组成：属性、方法、构造器、代码块、内部类

package yes.JavaSE.OOP;

public class JavaSE_220213_APerson {
    //名词 --- 属性（注意：只把有需要的内容写进代码，不相关的东西不要放到代码）
    //成员变量
    String name;//年龄
    int age;//姓名
    double height;
    double weight;
    char a;
    byte b;
    short c;
    long d;
    float e;
    double f;

    //动词 --- 方法
    //吃饭
    public void eat(){
        int num=0;//局部变量，必须初始化
        System.out.println("我喜欢吃饭");
    }
    //睡觉
    public void sleep(String address){
        System.out.println("我在"+address+"睡觉");
    }
    //自我介绍
    public String introduce(){
        return "我的名字是:"+name+",我的年龄:"+age+",我的身高是:"+height+",我的体重是:"+weight;
    }
}

创建对象

package yes.JavaSE.OOP;

public class JavaSE_220213_BTest {
    //main方法，程序入口
    public static void main(String[] args) {
        //创建一个人类的具体实例
        //new的结果放入堆中，返回地址，使用引用数据类型来接收
        //JavaSE_220213_APerson属于引用数据类型
        //第一次加载类时，会进行loadCLass类加载
        JavaSE_220213_APerson zs = new JavaSE_220213_APerson();
        zs.name="张三";
        zs.age=19;
        zs.height=180.4;
        zs.weight=170.4;

        //再创建一个对象
        //第二次加载类时，不会进行loadCLass类加载，类的加载只进行一次
        JavaSE_220213_APerson ls= new JavaSE_220213_APerson();
        ls.name="李四";
        ls.age=21;
        ls.height=170.6;
        ls.weight=130.8;

        //对属性进行读取
        System.out.println(zs.name);
        System.out.println(ls.age);

        //对方法进行操作
        //对于不同的对象，属性都有各自自己的值，但方法都调用类中通用的方法
        //属性是独立的，方法是共享的
        System.out.println(zs.introduce());
        zs.eat();
        System.out.println(ls.introduce());
        ls.sleep("卧室");
    }
}

内存分析

栈
setAge()
a 66
change3()
p 0x37
main()
jack = 0x37
tom = 0x83
age=40
t = 0x99
堆
new Person()tom 0x83
tom 1,20,0x16
new Person()jack 0x37
jack 2,66,0x28
Pointer PERSON
new Test() 0x99
Pointer TEST
方法区
LOAD CLASS TEST
LOAD CLASS PERSON
字符串常量池
Haidian 0x16
Chaoyang 0x28
Xicheng 0x22

this的使用

1、this修饰属性（不发生重名时可以省略）
2、this修饰方法（可以省略）
经典写法

同一个类中的构造器也可以用THIS相互调用，但要注意THIS修饰构造器，必须放在第一行。

static的使用

• 可以修饰属性、方法、代码块、内部类
• 在类加载的过程中，会将静态内容加载到方法区的静态域
• 静态的内容先于对象存在
• 静态内容被所有该类的对象所共享
• 可以通过“类名.属性名”的方式访问静态属性
• 静态属性（类属性）+非静态属性（成员属性）？

• 在静态的方法里不可以访问非静态属性
• 在静态的方法里也不可以访问非静态的方法
• 在静态的方法里也不能使用THIS
• 在同一个类中，可以直接调用静态方法

package yes.JavaSE.OOP;

public class JavaSE_220215_AStatic {
    String name;
    int age;
    static String school;

    public void a(){
        System.out.println(name);
        System.out.println(school);
        System.out.println("00001");
    }

    public static void b(){
        //System.out.println(school);
        System.out.println("00002");
    }

    public static void main(String[] args) {

        JavaSE_220215_AStatic.school = "yizhong";
        //JavaSE_220215_AStatic.b();
        b();

        JavaSE_220215_AStatic st = new JavaSE_220215_AStatic();
        st.name = "zhangsan";
        st.age = 19;
        //st.a();
        //st.school = "yizhong";

        JavaSE_220215_AStatic st2 = new JavaSE_220215_AStatic();
        st2.name = "lisi";
        st2.age = 12;
        //st2.school = "yizhong";

        JavaSE_220215_AStatic st3 = new JavaSE_220215_AStatic();
        st3.name = "wangyu";
        st3.age = 22;
        //st3.school = "yizhong";

        //System.out.println(st2.school);
    }
}

代码块

普通块：写在方法中，限制了局部变量的作用范围
构造块：在方法外写代码时使用（一般用的比较少）
静态块：static修饰的代码块，在静态块中只能访问静态属性、静态方法
同步块：用于多线程

• 执行顺序：静态块–》构造块–》构造器–》普通块
• 静态块只在类加载的时候执行一次，一般用于进行全局的初始化动作
• 构造块不常用

import的使用

1. 包的作用

为了解决重名问题，实际上包对应的就是盘符上的目录
解决权限问题

2. 包的创建

命名规则：全部小写，用.隔开，一般是公司域名倒着写
包声明：一般在非注释性代码的第一行

3. 包的导入

IDEA中：option/alt+enter 自动导包
在导包以后，还想用其他包同名的类，就必须手动写出所在包
在java.lang下的类，可以直接使用无需导包
静态导入：导入包的静态内容，使用时可以省略包名

package yes.JavaSE.OOP;

//静态导入
import static java.lang.Math.*;

public class JavaSE_220216_AImport {
    public static void main(String[] args) {
        System.out.println(PI);
        System.out.println(random());
        System.out.println(round(3.23));
    }
}