Java类与对象基本知识点

类和对象
什么是类（自行车设计图）

什么是对象（一辆辆的自行车）

为什么要设计类和对象的机制（面向对象编程）
状态 + 行为
属性 方法

面向对象的三大特性：封装 | 继承 | 多态

语法：
1） 定义类的语法
修饰符（modifier）class 类名称
{
1、属性
2、方法
3、构造方法
}
public class HelloWorld {…}
2）如何定义属性
修饰符（modifers）变量类型 变量名称；
默认值：
3）如何定义方法
修饰符（modifers）返回值类型 方法名称（形参列表）{
实现
}
public static int[] rotate (int[] a,int k){}
4)如何定义构造方法
构造对象的语法 | 对象实例化的语法
create object | instance（动词）
类名称 变量名称 = new 类名称（实参列表）
（引用类型-类引用）
new 类名称（实参列表）；
对象中存储的最主要的就是属性，也可以找到方法区中对象相对应的类。

    **如何访问对象的属性**        
    在类的内部        

    在类的外部

    **如何调用对象的方法**       
    在类的内部       

    在类的外部
    **内部：**    
    属性：直接通过属性名称访问即可    
    方法：直接通过方法名称调用即可
    **外部：**  
      属性：引用.属性名称    
      方法：引用.方法名称（实参列表） 

   ****容易混淆的地方**
       **嵌套调用****
   System.out.println(Arrays.toString(rorate(new int[] {1,2,3,4,5},3)));
   分解：int[] tmp1 = new int[] {1,2,3,4,5};
              int[] tmp2 = rotate(tmp1,3);
              String tmp3 = Arrays.toString(tmp2);
              System.out.println(tmp3); 
         **链式调用**
         class A {    
         public  A  create() {                
         return  new  A();               
         //A  tmp1 = new A();               
         //return  tmp1;}}

         class B {         
          public  static  void  main()) {              
           new A().create().create().create().create();             
            //A  tmp1 = new A();              
            //A  tmp2 = tmp1.create();              
            //A  tmp3 = tmp2.create();              
            //A  tmp4 = tmp3.create();              
            //A  tmp5 = tmp4.create();}}

Person p = null;
定义了一个没有指向任何对象的Person类型的引用（类类型的引用）

Person p = new Person（…）;
1)定义了一个Person类型的对象
2）定义了一个指向Person类型的对象的Person类型的引用（类类型的引用）

引用类型和指向的对象类型是两回事

this关键字的使用
1）在构造方法中调用其他的构造方法。调用语句必须出现在第一行
class Person(){
String name;
public Person(String n) {
name = n;
}
public Person() {
this(“陌生人”);}}
2)通过this访问属性或方法（一般出现在发生了命名遮挡的时候）（ name shadowing）
class Person() {
String name;
public Person(String name) {
name = this name;
toString(); //this.toString();
}
public String toString() { … };
}
3)this代表就是当前对象的引用（current object ）
class Person {
String name;
public Person(String name) { this.name = name;}
public String toString() { return this.name;}
public boolean equals(Person p) { return p.name = this.name;}
public void test() {this.equals(this);}}
**重点：**普通属性和普通方法，其实都绑定着一个隐含的对象标准输入 stdin 键盘
标准输出 stdout 屏幕
标准错误输出 stderr 屏幕
包（package） import java.util.Arrays
定义一个包
组织代码 和目录一致（不是准确定义）
定义包：
1）新建目录，目录名称就是包名称 （全小写，单词之间用下划线_分割）package hello_world;
定义目录
p1/p2/p3; 定义一个类HelloWorld； package p1.p2.p3
2） 使用包
import 包名称.类名称
import p1.p2.p3.HelloWorld;
访问限定符
1.限定符 2.影响的是访问权限
两种情况：
1.修饰顶级（Top-level） 2.修饰成员级(Member-level)四种访问限定符
说法 | 定义语法 | 说明
public public 所有类都有访问权限
package-private | 空白 | 只有一个包的类有权限访问
protected | protected |
private | private | 只有本类有访问权限

a包的A类定义的属性 | a包的A类方法中 | a包下B类方法中 | b包的C类方法中
public 有 有 有
package-private 有 有 没有
private 有 没有 没有
静态方法 | 静态属性
1） 方法
普通方法 | 静态方法（类方法）
2） 属性
普通属性（属性） | 静态属性（类属性）
语法
1.限定符 static
被static修饰的属性就是静态属性
被static修饰的方法就是静态方法
理解：
普通属性/普通方法 都绑定着一个隐含着的对象 （this）
static的含义就是和对象解绑
静态属性不再保存在对象（堆区）中，而是保存在类（方法区）中
静态方法调用时，没有隐含着的对象，所以也就无法使用this关键字
访问静态属性/调用静态方法语法：
内部
属性名称；
类名称.属性名称；
this.属性名称 //保证当前方法不是静态方法
方法名称（实参列表）：
类名称.方法名称（实参列表）;
this.方法名称（实参列表）；//保证当前方法不是静态方法
外部
类名称.属性名称
对象的引用.属性名称
类名称.方法名称（实参列表）；
对象的引用.方法名称（实参列表）；
强调：
在静态方法（静态上下文）中，无法使用this关键字。因为没有一个隐式的对象和该方法绑定。
1）不能访问普通属性
2）不能调用普通方法
表现出来的特性：
一个类的所有的对象，是可以共享静态属性的；（可以适当的看作C语言中的全局变量）

发生在对象实例化的时候
属性的初始化 1）和2）优先执行，按照定义顺序 3）最后执行
1）定义时初始化 int a =10；
2）构造代码块 { a=10； }
3）在构造方法中初始化 Person（）{ a=10； }

发生在类被加载的时候
静态属性的初始化
1）定义时初始化 1）和2）按照定义顺序依次执行
static int a = 10；
2）静态构造代码块
static { a = 20；}
类的信息一开始是以字节码（bytecode） *.class 形式保存在磁盘上的
类的加载过程就是 类加载器（ClassLoader）在对象的目录上找到指定类的字节码文件，并进行解析，然后放到内存的方法区的过程
类只有在被使用到的时候才会进行加载（一般不会卸载）
1）用类去实例化对象
2）调用静态方法
3）访问静态属性
类的加载一定是发生在对象实例化之前
访问限定符
static 限定符 静态属性 | 静态方法
初始化的机制（静态属性的初始化 | 属性的初始化）