Java基础学习之类与对象

一 类和对象的简单解释

类: Java中最基本的单位 是对一类抽象概念的描述(模板),类中定义的就是属性(一般用名词描述)和行为(一般用动词描述).

对象: 对象是一种具体的个性表示,类创建出的一个具体事物就是对象.

举个例子:描述一个程序员

属性: 姓名 性别 身高 年龄;

行为: 钱多事少死的早 技能

对象: xxx 男 180cm 25 会写代码.

规定特征:

1) 封装:隐藏代码的属性和实现,不能随意更改 ,需要开放访问方式;

2)继承:在原本的基础上扩充;

3)多态:在一个指定的范围之内进行概念的转换.

二 类和对象的定义和应用

class 类名{
属性(成员变量  实例变量) 书写位置:类中方法外
行为(方法 函数)跟函数一样 就static先不写  书写位置:类中.
}
类名要用大驼峰命名法

实例:定义一个学生类

class Student{
	String name;//属性
	int age;
	String gender;
	 //行为 方法
	 public void  eat(){
		 System.out.println("吃饭");
	 }
	 public void  sleep(){
		 System.out.println("睡觉");
	 }
	 public void  playGame(String game){
		 System.out.println("打"+game);
	 }
	//介绍自己的方法
	 public void sayHi() {
		System.out.println("姓名"+name);
		System.out.println("年龄"+age);
		System.out.println("性别"+gender);
	}
}

类定义完成后不能直接使用,需要通过对象.

如下实例化对象产生后,进行类的操作

创建学生类的对象

类名 对象名称 = new 类名();对象的引用 保存的对象地址

对象.属性:表示调用类中的属性;

对象.方法名(): 表示调用类中的

public static void main(String[] args) {
		//创建一个学生类的对象
		// 成员变量会随对象一起进入堆内存中 并且只要new一次就在堆内存中
		//开辟一块内存空间;
		Student stu1 = new Student();
		//使用对象名.属性名  进行赋值和取值
		stu1.name = "海哥";
		stu1.name = "hidan";
		stu1.age = 26;
		stu1.gender = "女";
		System.out.println(stu1.name);
		System.out.println(stu1.age);
		System.out.println(stu1.gender);
		// 调用成员方法 : 对象名.方法名()
		stu1.eat();
		stu1.playGame("王者荣耀");
		//哪个对象调用该方法 打印的就是那个对象的属性
		stu1.sayHi();
		Student stu2 = stu1;
		stu2.name = "董小姐";
		stu2.sayHi();
		
	}

局部变量同成员变量的区别:

1.书写位置

成员变量:类中方法外

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

 2.在内存中表现

成员变量: 堆中

局部变量: 栈中

 3.生命周期

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

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

 4.作用域

成员变量:整个类中

局部变量:方法中

 5.初始值

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

局部变量:没有初值,必须定义  不给初值 ,编译报错;

不同包下的类:

同名类需要

指定完整的包名来创建对象,例:

com.lanou4g.person p2 =new com.lanou4g.person();//

三 对象引用传递初步分析

如下例子

public class Demo04 {
	// 参数是基本数据类型
	public static void fun1(int a) {
		System.out.println(a);
		a=10;
	}
	// 参数是引用数据类型
	//要什么类型给什么类型 
	public static void fun2(person p) {
		p.name = "SD";
		p.age = 20;
	}
	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.只调用一下方法(不赋值)

1.

public static void setNameAndAge(person p,String name,int age) {
		p.name = name;
		p.age = age;
		p.sayhi();
		
	}

public static void main(String[] args) {

setNameAndAge(new person(), "kun", 20);}// 打印结果 kun 202.

new person().name = "xin";
		new person().age = 20;
		new person().sayhi();
		//只调用方法可以使用
		new person().fun();

五 封装

在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。

封装的好处

1.提高代码的复用性

2.提高代码安全性 

实现Java封装的步骤

关键字(权限修饰符) private 

public class Person {
    private String name;
    private int age;
}

  name  和  age  属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏.
对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，例如：

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(" 我是pen的有参构造方法");
	}
	
	//介绍方法
	public void  sayhi() {
		//使用this可以区分局部变量和成员变量
		String name = "yusadn";
		System.out.println(this.name+" "+this.color);
	}
	//set/get 方法
	public String getName() {
		return name;
	}
	public String getColor() {
		return color;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setColor(String color) {
		this.color = color;
	}
}

public static void main(String[] args) {
		// 创建一个 pen对象
		// 构造方法 是系统自动调的
		// 只要你创建对象,系统就会帮你调用构造方法
		// 构造方法只能调用一次
		Pen pen = new Pen();
		pen.sayhi();
		/*pen.setName("dili");
		pen.setColor("yellow");
		System.out.println(pen.getName());
		System.out.println(pen.getColor());*/
		
		// 测试有参构造方法
		Pen pen1 = new Pen("钢笔","绿色");
		pen1.sayhi();
	}

在上面的例子中构造方法 是对成员变量进行初始化;

写法:

1.

没有返回值的位置(连void都不要)

2.

方法名 要与类名完全一致;