类             对象

class         object(按照 英文就是东西,但是专家说是对象 so 我们就学对象)


类 class 就是 类型


因为 对象  object  ==》 东西 啥都是东西 ==> 啥都是对象 《== 专家的说法  一切皆对象


                        是结构化数据


类是对象的分类

类是对象的数据结构定义==》 对象有什么数据由类定义

  创建对象,需要有类型, 用类型创建对象 类是对象的结构模板


使用new 类名()   来创建对象   也叫做实例化



    对象创建后,成员变量可以按照默认的方式初始化

    数值类型     0

    int        0

    byte       0

    short       0

    long       0L

    float      0.0f

    double      0

    boolean类型    false

    char类型     \u0000

    引用类型     null

    



为了能够对实例化的对象进行访问控制,需要一个特殊的变量, 就是引用


引用类型

    8种基本类型之外的 用类名(接口\数组)声明的变量 就是引用类型变量

     引用类型变量的值中存储的是某个对象在内存中的地址信息,在一个引用类型变来那个指向该类的对象,就可以通过这个变量对  对象 访问


方法:

    在类中定义

    代表对象的行为 就是功能

    方法实现是利用算法操作对象的数据实现

    使用对象调用方法


    this 关键字

        this 在方法执行期间代表调用方法的“这个”对象。是动态绑定到当前对象,方法在方法区中通过this 识别不通对象的调用。

    代表当前对象本身是方法的隐含参数,接受对象引用

        本质


    堆栈 里面是数据

    方法区是算法

package day15;

public class Demo01 {

	public static void main(String[] args) {
		dog wangcai = new dog();
		wangcai.age=3;
		wangcai.name="wangcai";
		wangcai.sex='m';
		wangcai.color=0x505050;
		System.out.println(wangcai.age);
		System.out.println(wangcai.name);
		System.out.println(wangcai.sex);
		System.out.println(wangcai.color);
		wangcai.eat();
	}

}
class dog{
	String name; //实例变量 : 每个对象实例拥有一个name
	int age;
	char sex;
	int color;
	public void eat(){
		System.out.println("吃");
	}
}
package day15;

public class Demo01 {

	public static void main(String[] args) {
		cell c1 = new cell();
		c1.row = 1;
		c1.col = 5;
		c1.color = 0x505050;
		cell c2 = new cell();
		c2.row = 1;
		c2.col = 6;
		c2.color = 0x505050;
		System.out.println(c1.row);
		c1.drop();
		c2.drop();
		System.out.println(c1.row);
		System.out.println(c2.row);
	}

}

class cell {
	int row;
	int col;
	int color;

	public void drop() {//下移
		row++;
	}

	public void leftShift() {//左移
		col--;
	}

	public void rightShift() {//右移
		col++;
	}
}


在同一个包中不能声明同名的类


构造器(使得创建对象方便简洁)

    构造方法:创建和初始化对象的方法(初始化属性)

    构造方法在类中声明

    构造方法的方法名与类名一致

    构造方法不能声明返回值

    使用new运算调用构造器,创建对象

    java根据构造器参数识别 不通的构造器

package day15;

public class Demo01 {

	public static void main(String[] args) {
		
		dog xiaowangcai = new dog("xiaowangcai", 5, 'm', 0x404040);// 对比wangcai的声明xiaowangcai的声明更便捷
		//dog xiaowangcai2 = new dog("xiaowangcai2", 4, 'w', 0x606060);// 创建对象很便捷啦。
		xiaowangcai.eat();
		//xiaowangcai2.eat();
	}

}

class dog {
	String name; // 实例变量 : 每个对象实例拥有一个name
	int age;
	char sex;
	int color;

	public dog(String name, int age, char sex, int color) {// 构造器(构造方法):为更便捷
		System.out.println(this.name);
		this.name = name;// 方法中的参数是局部变量
		System.out.println(this.age);
		this.age = age;// this.age是实例变量
		System.out.println(this.sex);
		this.sex = sex;// 为了区别 就使用this. 区别方法参数和实例变量
		System.out.println(this.color);
		this.color = color;
	}

	public void eat() {// 方法
		System.out.println("吃");
	}
}

wKiom1YOOh7hnk4GAAehJ80h9jc819.jpg

java 构造方法和方法

    构造方法(构造器、构造函数) 对比 方法

        构造方法:方法名一定与类名一样,不能定义返回值 试用new运算调用构造fangfa

    

        方法:方法名一般不与类型一样,一定定义返回值 没有返回值的使用void的定义 试用引用调用方法

    


        构造方法:用于创建对象初始化属性:创建个小旺财


        方法:是对象的行为功能:狗吃东西


类型用名词

方法用动词

 名词 + 动词


重载:

    名字一样功能不同

            

    运算符:+ 数值相加 连接字符串

    方法重载:方法名一样,参数不同

    构造器重载:构造方法名一样,参数不同


package day15;

public class Demo01 {

	public static void main(String[] args) {

		dog xiaowangcai = new dog("xiaowangcai", 5);// 对比wangcai的声明xiaowangcai的声明更便捷
		dog xiaowangcai2 = new dog("xiaowangcai2", 4, 'w', 0x606060);// 创建对象很便捷啦。
		xiaowangcai.eat();// 调用重载的方法
		xiaowangcai2.eat("骨头");// 调用重载的方法
	}

}

class dog {
	String name; // 实例变量 : 每个对象实例拥有一个name
	int age; // 属性
	char sex;
	int color;

	public dog(String name, int age) {// 构造器(构造方法):为更便捷
		this.name = name;// 方法中的参数是局部变量
		this.age = age;// this.age是实例变量
		System.out.println(this.name);
		System.out.println(this.age);
	}

	// 构造器重载 参数不同 没有 sex 和color
	public dog(String name, int age, char sex, int color) {// 构造器(构造方法):为更便捷
		this.name = name;// 方法中的参数是局部变量
		this.age = age;// this.age是实例变量
		this.sex = sex;// 为了区别 就使用this. 区别方法参数和实例变量
		this.color = color;
		System.out.println(this.name);
		System.out.println(this.age);
		System.out.println(this.sex);
		System.out.println(this.color);

	}

	public void eat() {// 方法
		System.out.println("吃");
	}

	// 重载的方法,方法名一样,参数不同
	// 调用有参数的就执行下面的
	public void eat(String str) {// 方法
		System.out.println("吃" + str);
	}
}

null 

空指针异常:引用变量的值是null,没用引用任何对象

    在null引用上调用了方法 属性会出现空指针异常

在访问方法 属性之前 对引用变量赋值,使变量引用对象 ==》解决

    有变量没有对象

    访问属性

    调用方法



package test;

public class One {

	public static void main(String[] args) {

		// 类名 引用 对象
		dog wangcai = new dog();// 使用new 来创建一个对象 旺财 调用默认的构造器
		// new dog 是为 dog 类 为模板 ,在堆中创建一个dog类的对象
		// 末尾的() :在对象创建后,立即调用dog类的构造函数,对刚刚生成的对象进行初始化,
		// dog wangcai 创建一个 dog 类的引用变量, 对象引用 栈中
		// = 是对象引用指向刚刚创建的dog对象

		dog wangcai2 = wangcai;// 赋值 引用类型之间的赋值不会创建一个新的变量

		dog xiaowangcai = null;// dog xiaowangcai 创建一个 dog 类的引用变量, 但是他指向空 就是没有对象
		// xiaowangcai.name = xiaowangcai;// NullPointerException(空指针异常)
		// 当一个引用的值为null的时候,如果通过引用访问对象成员变量或者调用方法是不合逻辑的
		// (因其没有指向某对象,自然不会有属性和方法)

		wangcai.name = "wangcai";// 通过 引用类型变量 访问 实例变量
		wangcai.age = 5;// 访问实例变量
		wangcai.print();// 调用对象的方法
		wangcai.print("是一个狗");// 根据 参数类型 调用了重载的方法
		wangcai.print('m');// 参数类型 调用了重载的方法
		cat tom = new cat("tom", 4); // 调用构造器使得创建对象方便简洁
		cat kitty = new cat("kitty", 3, 'w');// 调用重载的构造器
		kitty.print();
	}
}

class dog {// 创建一个类
	String name;// 类中创建的实例变量
	int age;// 类中创建的实例变量

	// public dog(String name,int age){//构造器
	// this.name = name;
	// this.age = age;
	// }
	//
	// 方法的签名包含如下两个方面:方法名和参数列表
	// Java语法规定,一个类中不可以有两个方法签名完全相同的方法,
	// 即:一个类中不可以有两个方法的方法名和参数列表都完全相同,
	// 但是,如果一个类的两个方法只是方法名相同而参数列表不同,是可以的
	public void print() {// 类中创建的方法 print
		System.out.println(name + ":" + age);
	}

	public void print(String thing) {// 重载为了好看 优雅
		System.out.println(name + thing);
	}

	// public void print(String sex){//重载 根据参数的类型判断
	// System.out.println(name+sex);
	// }
	public void print(char thing) {// 重载
		System.out.println(name + " is " + thing);
	}
}

class cat {
	String name;
	int age;
	char sex;

	public cat(String name, int age) {// 构造器
	// JAVA语法规定,任何一个类都必须含有构造方法,假如源程序中没有定义,则编译器在编译时将为其添加一个无参的空构造方法(此方法称之为“默认的构造方法”)
	// 使得创建对象方便简洁
	// 构造方法的名称必须与类名相同。
	// 构造方法没有返回值,但也不能写void。
	// Java语言中的构造方法常常用于实现对对象成员变量的初始化

	    this.name = name;// this关键字用在方法体中,用于指代调用该方法的当前对象,
	// 简单的说:哪个对象调用方法,this指的就是哪个对象。
	// 严格来讲,在方法中需要通过this关键字指明当前对象
	    this.age = age;// 在构造方法中,用来初始化成员变量的参数一般和成员变量取相同的名字,这样会有利于代码的可读性,但此处就必须通过this关键字来区分成员变量和参数了,而不能省略this了
	}

	public cat(String name, int age, char sex) {// 重载的构造器
		// 很多时候,为了使用的方便,可以对一个类定义多个构造方法,
		// 这些构造方法都有相同的名称(类名),只是方法的参数不同,称之为构造方法的重载。
		this.name = name;
		this.age = age;
		this.sex = sex;

	}

	public cat(String name) {// 重载的构造器
		// 使用了this关键字,在构造方法中可以通过this关键字来调用另外的一个重载的构造方法。
		// this ( name,3,'w')调用了cat(String name,int age ,char sex)构造方法
		this(name, 9, 'w');
	}

	public void print() {
		System.out.println(sex);

	}

}



最后:对象就是东西!!!