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;
}
}
