Java码农进阶之路~面向对象之对象和类

一 类和对象的概念

1.对象

在Java中,对象具有属性和方法.属性为对象的一般特征(抽象描述),方法为对象的一些行为.(对象是由类创建出来的具体的事物)

例如用对象描述一个程序员

属性: 姓名 性别 年龄

方法(行为): 吃饭,睡觉,敲代码

2.类

java中最基本的单位就是类.类是一堆抽象事物的描述(模板).也可以说类是具有相同属性和方法(行为)的一组对象的集合.当然,类也具有属性和方法.

3.类与对象的关系

可以说类是一组具体事物的相同特征(属性)和行为(方法)的抽象描述,而对象即为类中的每一个具体事物.

二 面向对象概念以及好处

1.面向过程

说面向对象之前先大致理解下面向过程.见名知意,面向过程的重点就在过程中,比如说在过程中做什么,也可以说是事务的执行者

例如挑选一个电脑

这个过程中,我们就要挑他的CPU,主板,显示器等并执行.

2.面向对象

由名称也可看出其重点在对象.就如做什么事,我们考虑的是找谁做.由事务的执行者变成了指挥者.

就如上个买电脑的例子.买电脑,我们不需要挑电脑的软硬件,而是仅仅需要找一个懂电脑的人帮我们去买就可以了.

可以说面向对象是一个贴近与人的思维(懒人思维).

3.面向对象的好处:

①将复杂问题简单化

②从事务的执行者 转化为 事务的指挥者

③更贴近于人的思维(懒人思维)

三 创建一个类(为力量创建一个抽象类的具体对象)

例如创建一个学生类

class Student{
	//属性书写位置(成员变量 实例变量) 
	//书写位置:类中方法外
	//行为(方法 函数) 跟函数一样 就static先不写
	//书写位置:类中
	String name;
	int age;
	String gender;
	
	//成员方法/实例方法
	public void eat() {
		System.out.println("吃饭");
	}
	public void sleep() {
		System.out.println("睡觉");
	}
	public void play(String game) {
		System.out.println("打游戏" + game);
	}
	//介绍自己的方法(行为):
	public void sayHi() {
		System.out.println("姓名:" + name);
		System.out.println("年龄:" + age);
		System.out.println("性别:" + gender);
	}
}

而创建类都是为了创建一个对象

public static void main(String[] args) {
	//创建一个学生类的对象出来
	//类型名 对象名 = 初值;
	//成员变量会随对象一起进入堆中
	//new 一次,就会在堆中开辟一块内存空间
	//Student stu 对象的引用(保存的是对象的地址)
	Student stu = new Student(); 
       	//使用 对象名.属性名 进行赋值和取值
	stu.name = "fas";
	stu.name = "fa";
	stu.age = 24;
	stu.gender = "男";
	//调用成员方法 对象名.方法名
	stu.eat();
	stu.play("英雄联盟");
	//那个对象调用该方法,打印的就是那个对象的属性
	stu.sayHi();
	//不new没有开辟一个新的空间,对同一个进行数据操作
	Student stu1 = stu;
	stu1.name = "fasf";
	stu.sayHi();
}

而上述所说的成员变量和局部变量可看这个例子

package com.lanou3g;
/*
 * 车类:
 * 车名 排气量 颜色
 * 开车
 * 停车
 */
class car{
	//声明成员变量的时候 可以给初值
	String name = "法拉利";//车名
	String displacement = "8.0T";//排气量 
	String color = "红色";//车颜色
	
	public void startcar(int a) {//方法上
		//在方法中的变量,是局部变量
		//在方法上的变量,是局部变量
		int num = 0;
		//就近原则
		String color = "红色";
		System.out.println(color);
		System.out.println("开车");
	}
	public void stopcar() {
		System.out.println("停车");
	}
	public void sayHi() {
		System.out.println("名字:" + name);
		System.out.println("排气量:" + displacement);
		System.out.println("车颜色:" + color);
	}
}

成员变量和局部变量的区别

1.书写位置

成员变量:类中方法外

局部变量:方法中或方法上

2.在内存中的表现

成员变量:堆内存

局部变量:栈内存

3.生命周期

成员变量:随着对象进入堆内存中创建,随着对象的销毁而销毁

局部变量:随着方法的调用入栈,随着方法的结束而销毁

4.作用域

成员变量:整个类中

局部变量:方法中

5.初始值

成员变量:跟堆内存一样,有默认初始值

局部变量:不给初值,直接编译报错

在创建对象的时候,如若创建不同包下下的同名类的对象,需要指定完整的包名来创建对象

而创建不同包下的不同名类的对象,

四 创建对象时参数的引用

public class Demo04 {
	//参数是基本数据类型
	public static void fun1(int a) {
		System.out.println(a);
		a = 10;
	}
	//参数是引用数据类型
	//要什么类型 就给什么类型
	public static void fun2(Person p) {
		p.name = "文武";
		p.age = 24;
	}

	public static void main(String[] args) {
		int a = 100;
		fun1(a);
		System.out.println(a);
		
		Person p1 = new Person();
		p1.name = "雨竹";
		p1.age = 28;
		fun2(p1);
		p1.sayHi();
	}
}	

数据的操作过程为

所以打印出来的是

五 匿名对象

匿名对象(没有名字的对象):

1.在方法传参数的时候使用

2.只调用一下方法(不赋值的情况下)

public class Demo05 {
	public static void setNameAndAge(Person p, String name, int age) {
		p.name = name;
		p.age = age;
		p.sayHi();
	}
	public static void main(String[] args) {
		//创建两个person对象 并赋值
		//将重复代码 抽成一个方法
		Person p1 = new Person();
		p1.name = "wanglong";
		p1.age = 16;
		p1.sayHi();
		
		Person p2 = new Person();
		setNameAndAge(p2, "menglong", 8);
		
		//使用匿名对象 当方法参数
		//好处:减少代码量 使用方便
		setNameAndAge(new Person(), "kun", 20);
		//匿名对象也是对象,也可以赋值属性,调用同样的方法
		new Person().name = "xin";//xin 0
		new Person().age = 30;// null 30
		new Person().sayHi();// null 0
		//new 在堆内存中开辟空间,所以打印了三个空间
		//只调用方法可以使用匿名对象-----测试方法时,可能会使用
		new Person().fun();
	}
}

所以其打印的结果为

六 封装

写方法就是封装的一种,相当于隐藏代码的实现和属性 不能随意修改

需要开放访问方式(方法) 获取 修改

好处:

1.提高代码的复用性

2.提高代码的安全性

关键字(权限修饰符)

private 私有的

被private修饰的属性 只能本类中访问

public class Demo06 {
	public static void main(String[] args) {
		Phone phone = new Phone();
		//测试 set get方法
		phone.setPhoneName("vivo");
		phone.setColor("红色");
		System.out.println(phone.getPhoneName());
		System.out.println(phone.getColor());
		phone.sayHi();
	}
}
class Phone{
	//java bean 对象(java 实体类创建出来的对象)
	//1.声明成员变量 都需要 私有化
	//2.给每一个成员变量提供 set/get方法
	//3.必须提供 无参的构造方法
	private String phoneName;
	private String color;
	
	//对外开放 访问方式
	//获取方法    get
	//命名规范 
	//	获取 get + 成员变量名(首字母大写)
	//	修改 set + 成员变量名(首字母大写)
	//	标准写法 set方法 没有返回值的
	public String getPhoneName() {
		return phoneName;
	}
	public String getColor() {
		return color;
	}
	//修改方法(设置方法)	set
	public void setPhoneName(String name) {
		phoneName = name;
	}
	public void setColor(String color) {
		//就近原则
		//关键字 this 代表的诗 本类的对象
		//this.成员变量  =  获取 本类的 成员变量
		//this.成员变量 = "哈啊哈";给本类的成员变量赋值
		//this.成员方法  调用本类的成员方法
		//谁调用了这个方法,谁就是这个this
		this.color = color;
		
	}
	
	public void sayHi() {
		System.out.println(phoneName + " " + color);
	}
} 

打印结果

七 有无参数的构造方法

/*
 * 构造方法:对 对象的成员变量进行初始化
 * 写法:
 * 1.没有返回值类型位置(连void都不写)
 * 2.构造方法方法名 要与 类名 完全一致
 */
public class Demo07 {
	public static void main(String[] args) {
		//创建一个pen对象
		//构造方法 是系统帮你调的
		//只要你创建对象 系统就会帮你调用构造方法
		//构造方法 只会执行一遍
		Pen pen = new Pen();
		pen.sayHi();
	/*	pen.setName("作弊笔");
		pen.setColor("红色");
		System.out.println(pen.getName());
		System.out.println(pen.getColor());*/
		
		//测试有参的构造方法
		//传参数 系统就会去找你有参的构造方法调用
		Pen pen2 = new Pen("钢笔", "绿色");
		pen2.sayHi();
		
		/*
		 * 类中写什么?
		 * 成员变量
		 * 无参构造方法
		 * 有参构造方法
		 * 成员方法
		 * set/get方法
		 */
	}
}

class Pen{
	/*
	 * 类中的书写顺序
	 * 1.成员变量
	 * 2.构造方法
	 * 3.成员方法
	 * 4.set/get
	 */
	private String name;
	private String color;
	
	//构造方法(无参)
	public Pen() {
		//初始化成员变量(给成员拜变量赋值)
		this.name = "圆珠笔";
		this.color = "绿色";
		System.out.println("我是pen类的无参构造方法");
	}
	//有参的构造方法(构造方法的重载)
	//为了再创建对象的同时 给成员变量赋值
	public Pen(String name,String color) {
		this.name = name;
		this.color = color;
		System.out.println("我是有参的构造方法");
	}
	
		
	//介绍自己的方法
	public void sayHi() {
		//使用this可以区分 成员变量 和 局部变量
		System.out.println(this.name + " " + this.color);
	}
	//set/get方法
	public void setName(String na) {
		name = na;
	}
	public void setColor(String col) {
		color = col;
	}
	public String getName() {
		return name;
	}
	public String getColor() {
		return color;
	}
	
}

打印结果为