类和对象

类和对象
1.什么是类（自行车的设计图）
什么是对象（一辆辆的自行车）
2.为什么要设计类和对象的机制（面向对象编程）
状态 + 行为
属性 方法
3.面向对象的三大特点：封装|继承|多态
4.语法：
1）定义类的语法
修饰符（modifier）class 类名称{
1.属性
2.方法/静态方法
3.构造方法（必须有，否则编译器会自动补一个）
}
2）如何定义属性
修饰符（modifier）变量类型 变量名称： 默认值：
3）如何定义方法
修饰符（modifier） 返回值类型 方法名称（形参列表）{
}
public static int[] ABC （int a）{
}
4）如何定义构造方法
修饰符（modifier）类名称（形参列表）{
}
5.构造对象的语法|对象实例化的语法
create object |instance
类名称 变量名称=new 类名称（实参列表）
（引用类型-类名称）
1）new关键字 计算对象内存大小，在堆中申请内存空间，把空间都初始化为0x0
2）
一个文件中只能有一个public的类，该类的名称必须和文件名一样一个类会生成一个class字节码文件

public class Test{
    public static void main(String[] args){
        Person p=new Person("小比特",2,4);
        System.out.println(p.toString());
    }
}
class Person{
    public String name=null;
    public int gender=0;
    public int age=0;
    public Person(){
        
    }//构造方法允许重载
    public Person(String n,int g,int a){
        name=n;
        gender=g;
        age=a;
    }
    public String toString(){
        return String.format("Person(%s,%d,%d)",name,gender,age);
    }
}
class Student{
    //没有明确的定义构造方法
    //虚拟机会自动定义一个构造方法
    //public Student(){
    //}
}

Person p=new Person(“小比特”,2,4);
3. 1. 2.
1)定义了一个Person类的对象1）计算对象需要的内存大小，开辟空间，初始化为0p=malloc(sizeof(Person));memset(p,0x0,sizeof(Person));
2）调用构造方法，对属性初始化
3）构造方法调用结束，返回一个指向对象的引用
Person temp=新对象；

类和对象的内存模型
类 方法区
属性 堆区对象中存储的最主要的就是属性，也可以找到方法区中对象相对应的类
语法:
1)如何访问对象的属性
在类的内部（在类的内部访问类的属性的调用类的方法）:直接通过属性名称访问即可
在类的外部:直接通过方法名称访问即可
2）如何调用对象的方法
在类的内部：引用.属性名
在类的外部：引用.方法名称（实参列表）

class Person{
    int a;
    int b;
    public void methodA(){
        a=10;
        System.out.println(a);
         methodB();
    }
    public void methodB(){
    }
}
class Main{
    public static void main(String[] agrs){
         Person p=new Person();
         p.a;//int[] a; a.length;
         p.methodA();
    }
}

容易混淆的地方：
嵌套调用：System.out.println(Arrays.toString(rotate(new int[]{1,2,3,4})));
链式调用

this关键字的使用

class Person{
    int a;
    int b;
    public void methodA(){
        a=10;
        System.out.println(a);
         methodB();
    }
    public void methodB(){
    }
}
class Main{
    public static void main(String[] agrs){
         Person p=new Person();
         p.a;//int[] a; a.length;
         p.methodA();
    } 
}

1）在构造方法中调用其它构造方法（调用语句必须放在第一行）
2）通过this访问属性或方法（一般出现在发生了命名遮挡的时候【name shadowing】）
3）this代表当前对象的引用注：普通属性和普通方法其实都绑定着一个隐含对象

class Person{
    public String name;
    pubic int age;
    public Person(String name,int age){
        this.name=name;
        this.age=age;//2
    }
    public Person self(){
        return this;
    }
    public String name(){
        return this.name;
    }
}

访问限定符
1.限定符 2.影响的是访问权限
两种情况 ：
1）修饰顶级（Top-level）
2）修饰成员级(Member-level)
四种访问权限：
代表顶级访问权限
说法 | 定义语法 | 说明
public | public | 所有类都有访问权限
package-private | 空白 | 只有一个包的类有访问权限
protected | pritected | 留到继承在补充privatae
private | private | 只有本类有访问权限
a包的A类定义的属性|a包的A类方法中|a包的B类方法中|b包的C类方法中
public | 有 | 有 | 有
package-private | 有 | 有 | 无
private | 有 | 无 | 无
静态方法|静态属性
1）方法
普通方法（方法）|静态方法（类方法法
2）属性 普通属性（属性）|静态属性（类属性）
语法：
1.限定符 static
被static修饰的属性就是静态属性
被static修饰的方法就是静态方法
理解：
普通属性/普通方法都绑定着一个隐含的对（this）
static的含义就是和对象解绑
静态属性不再保存在对象（堆区）中，而是保存在类（方法区）中
静态方法调用时，没有隐含着的对象，所以也就无法使用this关键字

class Person{
    String name="小比特";
    String toString(){
        return this.name;
    }
    static Person createPerson(){
         return new Person();
    }
}

真的没有形参
访问静态属性/调用静态方法的语法：
内部：
属性名称；
类名称.属性名称；
this.属性名称；//保证当前方法不是静态方法
方法名称（实参列表）；
类名称.方法名称（实参列表）；
this.方法名称；//保证当前方法不是静态方法
外部：
类名称. 属性名称；
对象的引用.属性名称；
类名称. 方法名称（实参列表）；
对象的引用.方法名称（实参列表）；
强调：在静态方法（静态上下文）中，无法使用this关键字。因为没有一个隐式的对象与该方法绑定。
1）不能访问普通方法
2）不能调用普通方法
表现出来的特性：
一个类的所有对象，是可以共享静态属性的；(可以适当看作C语言的全局变量)
属性的初始化（发生在实例化的时候）1）和2）优先执行，按照定义顺序；3）最后执行
1）定义是初始化 int a=10;
2）构造代码块
{
a=10;
}
3)在构造方法中初始化
Person(){
a=10;
class A{
a=0;
int a=10;
a=20;
}
A(){
a=30;
}
}
静态属性初始化（发生在被加载的时候）
1）定义是初始化 1）和2）按照定义顺序执行
static int a=10；
2）静态构造代码块
static{
a=20;
}
类的信息一开始是以字节码（bytecode）*.class的形式保存在磁盘上的
类的加载过程就是类加载器（classLoader）在对象的目录上找到指定类的字节码文件，并进行解析，然后放到内存的方法区的过程
类只有被使用到的时候才会进行加载（一般不会卸载）
类的加载一定是发生在对象实例化之前
1）用类去实例化对象
2）调用静态方法
3)访问静态属性