Java 面向对象语言基础

面向过程 就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。
面向对象 是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

1、 区分类、对象和对象的引用

对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。

类：类是一个模板，它描述一类对象的行为和状态。

创建对象
对象是根据类创建的。在Java中，使用关键字new来创建一个新的对象。创建对象需要以下三步：

• 声明：声明一个对象，包括对象名称和对象类型。
• 实例化：使用关键字new来创建一个对象。
• 初始化：使用new创建对象时，会调用构造方法初始化对象。

public class Ch_4_1{
	
    public static void main(String[] args) {
        Pet a=new Pet();                  //根据Pet类创建出一个对象
        System.out.println("A Pet object is created.");
        a.name="Snoppy";                 //修改对象的状态，即对属性成员赋值
        a.showMe();                       //操控对象的行为（或调用对象对外提供的服务）
    }
}	  
class Pet{
	String name;            //定义成员变量
	
	void showMe(){          //定义成员方法
		System.out.println("Hi, I'm "+name +" !"); 
	}
}

运行结果

A Pet object is created.
Hi, I'm Snoppy !

【说明】

• 类中的内容统称为成员 ----> 成员变量、成员方法。
• 只能通过引用名来操控对象，不能通过属性值。如本例中的a.name、a.showMe()，均为正确写法。
• 一个Java文件可包含多个类，但是只能存在一个public修饰的类，因为文件名必须与public类同名。若无public类，则文件取名只要满足标识符命名规则即可。文件中每个类（或接口），编译后都会产生一个单独的.class文件与之对应。
• 类成员可以缺省，俗称空类

class Species{}

对象和对象引用的内存管理

1、内存空间的自动管理机制：基于栈的内存管理模式

特色：栈空间的数据被系统自动管理，即在函数调用时自动创建数据空间，在函数运行结束时自动释放数据空间。栈空间中的数据与特定函数直接相关。程序员在函数中定义的所有变量，无论是基本类型还是引用类型，均存储在栈空间。
2、内存空间的手动管理机制：基于堆的内存管理模式

特色：在程序中给出申请或释放内存单元的指令，可实现内存单元的按需分配或释放。其中堆是一种无结构的内存区域，用于执行期间内存单元的动态分配和释放。所有对象均存储于堆空间。

2、 构造函数

关于java类中的构造方法：

• 构造方法又被称为构造函数/构造器/Constructor

• 构造方法语法结构：
  [修饰符列表] 构造方法名（形式参数列表）{
  构造方法体；
  }

• 普通方法的语法结构：
  [修饰符列表] 返回值类型 方法名 （形式参数列表）{
  方法体
  }

• 对于构造方法来说，“返回值类型不需要指定，并且也不能写void,
  只要写上void,那么这个方法变成普通方法

• 构造方法的方法名必须和类名保持一致

• 构造方法的作用？
  -构造方法存在的意义是，通过构造方法的调用，可以创建对象
  -初始化实例变量的内存空间

• 构造方法应该怎么调用？
  -普通方法：方法修饰符中有static的时候：类名.方法名（实参列表）、方法修饰符列表中没有static的时候：引用.方法名（实参列表）
  -new 构造方法名（实参列表）

• 构造方法调用之后，有返回值吗?

  每一个构造方法实际上执行结束后都有返回值，但是这个"return值;"这样的语句不需要写。构造方法结束的时候java程序自动返回值
  并且返回值类型是构造方法所在类的类型，由于构造方法的返回值类型就是类本身，所以返回值类型不需要编写
  

• 当一个类中没有定义任何构造方法的话，系统默认给该类提供一个无参数的构造方法，这个构造方法被称为缺省构造器

• 当一个类显示的将构造方法定义出来了，那么系统不再默认为这个类提供缺省构造器。建议手动提供

• 构造方法支持重载机制。在一个类当中编写多个构造方法，这多个构造方法显然已经构成方法重载机制

public class ConstructorTest01 {

	public static void main(String[] args) {
		
		User u1 = new User();
		User u2 = new User(10);
		User u3 = new User("zhangsan");
		User u4 = new User(10,"zhangsan");
		
		//有static的方法调用,同一个类中类名可要可不要
		ConstructorTest01.dosome();
		dosome();
		//无static的方法调用，需要先创建对象
		ConstructorTest01 t = new ConstructorTest01();
		t.doOther();
	}
	public static void dosome() {
		System.out.println("do some!");
	}
	public void doOther() {
		System.out.println("do other!");
	}
}

运行结果
带有int类型参数的构造器
带有String类型的构造器
带有int,String类型的构造器
do some!
do some!
do other!

public class User {

	//无参数的构造方法
	public User(){
		System.out.println();
	}
	
	//有参数的构造方法
	public User(int i) {
		System.out.println("带有int类型参数的构造器");
	}
	
	public User(String name) {
		System.out.println("带有String类型的构造器");
	}
	public User(int i,String name) {
		System.out.println("带有int,String类型的构造器");
	}
	
}

运行结果
构造函数 P() 被执行!
构造函数 B() 被执行!
构造函数 C() 被执行!

显然，若要构造出C的对象，必须先构造出其源自超类B的对象部分。同理，要构造出B的对象，则应先构造出A的对象部分。这说明在构造子类时，会自动调用超类的构造函数，调用次序与派生次序相同。

☁ 空指针引用
所谓空指针引用，就是当引用变量未关联任何对象时，却引用其成员。

public class Ch_4_7{
	public static void main(String[] args){
		C c=new C();
		//c.b=new B();c.b.a=new A();
		//System.out.println(c.b.a.x); //此句运行时报错
		C c1=new C();
	}
}

class A { 
	public int x;
	}
 
class B { 
	public A a; 
	}

class C { 
	public B b; 
	}

☁ 相等判断
对象相等有两层含义：
1）两对象实为同一对象，即对象的起始地址相同；
2）两对象不是同一对象，但对象的特定属性值对应相等。

/*本例表明：A的equals()与String的equals()功能不同；
 *前者作用等同于"=="；
 *后者是判断“字符串字面量的值”是否相同；
 **/

public class Ch_4_8{
	public static void main (String[] args) {
		A a=new A();    A b=new A();
		System.out.println(a==b);              //输出false。因为a、b指向不同的对象
		System.out.println(a.equals(b));      //输出false。因为a、b指向不同的对象
		String s1=new String("abc");
		String s2=new String("abc");
		System.out.println(s1==s2);          //输出false。因为s1、s2指向不同的对象
		System.out.println(s1.equals(s2));  //输出true。因为s1和s2存储的字符串值相同
	} 
}
class A{int x=5;}