Java SE第五课：面向对象编程—类与对象（上）

1.类和对象<理解起来有点抽象>
1>.类？→相当于设计稿
对象？→设计并制作出来的成品
面向对象编程：状态（属性）+行为（方法）
2>.面向对象的三大特性：封装、继承、多态
2.语法
进行类定义的顺序：①定义属性；②定义构造方法；③定义普通方法.
1>.定义类的语法：

修饰符(modifier) class 类名称{
     ①属性 / 静态属性
     ②方法 / 静态方法
     ③构造方法
}     
例:public class  HelloWorld{-------}

2>.定义属性的语法：

修饰符(modifiers) 变量类型 变量名称；
例:public String name;

3>.定义方法的语法：

修饰符(modifiers) 返回值类型 方法名称(形参列表){
           实现语句               <变量有类型>
}  
例:public static int[] rotate(int[] a,int i){
                -----------
   }

4>.定义构造方法的语法：

修饰符(modifiers) 类名称(形参列表){
           执行语句
}
例:public Person(String[] name,int age){
           执行语句
   }

5>.构造对象的语法 | 对象实例化的语法：
create object | instance（动词)

类名称 变量名称=new 类名称(实参列表)；
                 （是常量赋的值，无类型）
String类型是引用类型，放在堆区
例:Person p=new Person("小朋友"，18);

6>.实例化对象的语法：

new 构造方法(实参)

①new 关键字计算内存大小，在堆中申请内存空间:把空间都初始化为0X0;
②执行构造方法，对属性进行初始化；
③把对象的引用赋值给一个引用变量，如果需要的话；
④对象的生命周期

橙：代表对象刚刚申请好空间，内部被初始化为0x0;
蓝：代表对象正在执行构造方法，对属性初始化部分；
红：代表对象的可使用生命周期阶段；
灰：代表对象已经被标记为垃圾，但可能还有被立即回收的时期.
7>.在一个程序中定义类，属性，方法，构造方法的举例说明：

class Person{  //定义类，一个文件中只能有一个public的类
    public String name=null;
    public int gender=0;  //0女；1男；2不方便说
    public int age=0;  //定义属性
    public String toString(){  //定义方法
         return String.format("Person(%s,%d,%d)",name,gender,age);
    }
    public Person(String n,int g,int a){  //定义构造方法
        name=n;
        gender=g;
        age=a;
        }
    }
    public class HelloWorld5{
        public static void main(String[] args){  //定义方法
             Person p=new Person("小朋友",2,4);
             System.out.println(p.toString());
             }
    }
    结果：Person(小朋友,2,4)
             

8>.需要注意的几点：
①new：计算对象需要的内存大小，开辟空间，初始化为0；
p=malloc(sizeof(Person)); malloc:向系统申请分配size字节的内存空间
memset(p,0x0,sizeof(Person)); memset:数据初始化
②构造对象里第二个Person:调用构造方法，对属性初始化 String s=“xyz”; s.legth();
③构造对象里第一个Person:构造方法调用结束，返回一个指向新对象的引用
Person tmp=新的对象； p.toString 访问对象的方法
④属性在对象里，对象存在堆区，所以属性应该存在堆区
⑤对象中存储的最主要的就是属性，也可以找到方法区中对象相对应的类
⑥如果没有明确写出构造方法，编译器自动补一个默认的无参构造方法；一旦你定义过构造方法了，无论是什么样的构造方法，默认这个无参构造方法就不再给你添加了
⑦一个源文件中只能有一个public的类，该类的名称必须和文件名一样
⑧一个类会生成一个class字节码文件
3.在类的内部，外部操作的语法
1>.访问对象的属性，调用对象的方法

2>.①Person p=null;
定义了一个没有指向任何对象的Person类型的引用（类类型的引用）
②Person p=new Person(实参列表)；
定义了一个Person类型的对象
定义了一个指向Person类型的对象的Person类型的引用（类类型的引用）
★引用类型和指向的对象的类型是两回事（多态章节讲）
4.this关键字的使用
1>.在构造方法中调用其他构造方法，调用语句必须出现在第一行

//伪代码
class Person(){
    String name;
    public Person(String n){
        name=n;
    }
    public Person(){
      1>.name="陌生人”;
      2>.  this("陌生人"); 
    }
}

2>.通过this访问属性或调用构造方法，一般是在出现了命名遮挡(name shadowing)的时候

//伪代码
class Person(){
    String name;
    public Person(String name){
        name=this.name;      //形参的名字与属性同名,前面的name是形参中的name
        toString();   
         //this.toString();
    }
    public String toString(){---}
}

3>.this代表的就是对当前对象的引用

//伪代码
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);
    }
}

4>.this关键字的一道例题

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

public class HelloWorld4 {
	public static void main(String[] args) {
		Person p = new Person("小比特", 18);
		System.out.println(p.self().name());
	}
} 
//结果：小比特

5.普通属性和普通方法，其实都绑定着一个隐含的对象
标准输入 stdin 键盘
标准输出 stdout 屏幕
标准错误输出 stderr 屏幕
类信息存在方法区，属性信息存在堆区