Java对象与类详解-优快云博客

类对象

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("吃");
	}
}

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

	}

}

最后：对象就是东西！！！

转载于:https://blog.51cto.com/lmdtx/1699923