Java学习笔记（12）-类，对象，引用

Object:对象，东西

一切皆对象==啥都是东西

对象：存在的一个东西！

类：概念，是同类型东西的概念。简单说就是“名词”

引用：代词，是对象的引用，就像拴着对象的绳子。

引用本身不是对象！引用指代了对象！

引用的值是对象的地址值，通过地址值引用了对象。

引用的值不是对象！

引用变量在运行期间动态绑定到对象！

变量不是对象，当变量的值是null时候，调用了变量的属性或者方法，会出现空指针异常！

Object类

所有类的父类，我们定义的类都是直接或者间接的继承自Object。

若我们定义的类不使用extends去显示的继承它，在编译的过程中也会自动被加入。强制继承自Object。

超类：就是父类superclass。Object是所有类的父类。

package day01;
/*
 * 类Point
 * 引用变量p1 p2
 * 对象 new Point()
 * 对象的本质是：复合数据结构封装，如：点封装属性(x,y)
 */
public class Demo07 {
	public static void main(String[] args) {
		Point p1;//引用”变量“，是对象的名字
		p1 = new Point();//对象p1(3,4)
		p1.x = 3;//.叫取成员运算，可以理解为”的“
		p1.y = 4;
		Point p2 = new Point();//p2(5,5)
		p2.x = 5;
		p2.y = 5;
		System.out.println(p1.x+","+p1.y);//3,4
		System.out.println(p2.x+","+p2.y);//5,5
	}
}
class Point{//类
	int x;
	int y;
}

package day01;

public class Demo08 {
	public static void main(String[] args) {
		Foo p1 = new Foo();
		System.out.println(p1.a);//0
		System.out.println(p1.b);//0.0
		System.out.println(p1.f);//false
		System.out.println((int)p1.c);//0
		System.out.println(p1.s);//null空表示什么都没有
		int a;//局部变量：main 方法中声明的局部变量
		//局部变量在栈中分配
	}
}
class Foo{
	int a;//是类中声明的实例变量，成员变量，自动初始化
	double b;//实例变量，对象属性：在堆中对象中分配
	boolean f;//每个对象都有自己的实例变量，属性
	char c;
	String s;
}

package day01;
/*
 * 重载：方法名一样，参数不同的方法后成重载的方法
 * 实现类似的功能。如：up() up(int dy) 相互构成重载
 * 调用方法：根据参数列表和方法名调用不同方法
 */
public class Demo09{
	public static void main(String[] args){
		Point1 p1 = new Point1();
		p1.x = 1;
		p1.y = 2;
		p1.up(3,2);
		System.out.println(p1.x+","+p1.y);
		Point1 p2 = new Point1();
		p2.x = 3;
		p2.y = 5;
		p2.up(2, 3);
		p2.up();
		System.out.println(p2.x+","+p2.y);
	}
}
//class Point{}//编译错误，在一个包packaeg中不能有同名的类
class Point1{
	int x;
	int y;
	public void up(int dx,int dy){
		y -= dy;
		x += dx;
	}
	public void up(){
		y--;
	}
}

package day01;
import java.util.Arrays;
/*
 * java API中的重载
 * Arrays.sort() Arrays.equals() Arrays.toString()
 * Arrays.binarySearch() println() print() Math.max()...
 */
public class Demo10 {
	public static void main(String[] args){
		int[] arr = {1,3,4,5,5};
		//Arrays.sort是重载的方法
		Arrays.sort(arr);//int[]
		String[] str = {"a","b","c","g","d"};
		Arrays.sort(str);//String[]
		//println是重载的方法，println(char[])
		int[] ary1 = {'a','b','c'};
		char[] ary2 = {'a','b','c'};
		System.out.println(ary1);//println(Object)
		System.out.println(ary2);//println(char[])
		System.out.println('中');//println(char)
		System.out.println((int)'中');//println(int)
	}

}

package day2;
/*
 * null 与 空指针异常
 * 引用变量不是对象，引用变量在运行期间动态绑定到对象，
 * 当变量的值是null的时候，调用了变量的属性
 * 或者方法，会出现空指针异常！
 */
public class Demo01 {
	public static void main(String[] args) {
		String s1;
		// System.out.println(s1);//编译错误，变量没有初始化
		s1 = null;// 引用类型变量可以赋值为null
		// null：空，就是没有
		// s1=null 表示有s1没有引用任何字符串对象
		// s1.charAt(0);//运行异常，空指针异常
//		test("hi");
		test("s1");// 运行异常，空指针异常
	}

	public static void test(String s) {
		// s变量不是字符串对象，在运行期间动态绑定到对象
		System.out.println(s.charAt(1));//在s的值是null时候异常
	}
}

package day01;

public class Demo11 {
	public static void main(String[] args){
		Point2 p1 = new Point2();
		p1.x = 3;
		p1.y = 4;
		p1.up(2);
		//up(p1,5);方法调用时当前对象引用p1隐含传递给this
		System.out.println(p1.y);;
	}
}
class Point2{
	int x;
	int y;
	public void up(/*point2 this*/int y){
//		this是方法中对当前对象的引用，本质是方法的隐藏参数
		this.y = this.y - y;
//		y = y -dy;
	}
}