大数据学习之路——java面向对象（一）

面向对象和面向过程都是一种编程思想,面向对象是由面向过程进化而来的

面向过程

一种比较早的编程思想,站在过程的角度思考问题,强调的是功能行为,功能的执行过程

PS:先干什么,再干什么,最后干什么

每一个功能都封装成一个方法,按照步骤一步一步实现

面向过程的缺陷
面向过程的设计,是由自上而下设计方式,在设计阶段就需要每一个模块,没有考虑有哪些方法(函数)来支撑当前模块的执行

在细化的时候,因为不是符合人类的思想,所以很难进行,维护性很差.

面向对象

面向对象是一种基于面向过程的编程思想,站在思想的角度是对象,会把多个功能放到不同的对象里面,此时不再强调函数本身,而是强调具备某些功能的"对象"

对象:具备某种功能的实体.

面向对象中,最小的程序单元是类

java中面向对象的三大特征

封装
就是不暴露内部信息给外部,提供一些接口让对方使用

继承
子类可以在父类的基础上获取有用的信息

多态
同一个事物被不同对象所触发,得到的结果是不一样的(例如重载)

类与对象

什么是抽象?

是从特定角度出发,从已经存在的一些事物中抽取出我们所需要关注的特征和行为,从而形成一个新的事物的过程,就叫抽象

什么是对象?

所有能够感知到的都是对象,世间万物皆对象

什么是类?

类是对象的抽象,类中存储着对象共有的特征

总结:
类是对象的抽象,对象是类的实例化(创建出来)

java中最基本的单元是类,java用class来描述事物

事物的属性—>成员变量

事物的行为—>成员方法

PS:面向对象就是把一组数据结构和处理他们的方法组成对象,把相同行为的对象归为类,通过类的封装隐藏内部细节,通过继承实现类的优化,通过多态实现

程序中体现类和对象

public class Student{
//成员变量 都有默认值
	int height;	//身高,整型,默认0
	int weight;	//体重	整型,默认0
	int age;	//年龄	整型,默认0
	char gander;	//性别	字符型,默认是一个空字符,不可见
	String name;	//名字	字符串,默认null
	//成员方法
	public void eat(){
		System.out.println("正在吃饭");
	}
	public void sleep(){
		System.out.println("正在睡觉");
	}
}

public class StudentTest{
	public static void main(String[] args){
		//类名 对象名 = new 类名();
		Student xiaoming = new Student();
		//访问对象成员变量或成员方法
		//对象名.类中可见的(public修饰)的成员属性
		//点--->the  资源定位符号--->可以通过这个点获取对应属性或方法
		System.out.println(xiaoming.age);	//打印默认值0
		xiaoming.name = "小明";
		System.out.println(xiaoming.name);
		//对象名.类中可见方法(public修饰)
		xiaoming.eat();
	}
}

PS:成员变量作用域,默认作用域实在类的内部,成员变量定义在哪个类中,成员变量的作用域就在哪个域中

随着访问权限修饰符的定义,可以跟随对象被谁访问

因为类是引用类型,所以类所创建出来的对象不能使用==进行比较,需要判断两个对象是否次相等需要会用equals

每次使用new关键字都会在堆中开辟一段新空间

没有通过new关键字所创建的类,只在栈中定义了对象名,没有在堆中开辟任何空间

构造方法
构造方法属于特殊方法

在创建对象时使用,构造方法多用于对成员变量赋值

没有返回值类型,没有其他修饰符,不会使用return并且方法名和类名一样

在创建类时,没有显式地提供构造方法时,系统会提供一个默认的构造方法,一旦显式地提供了构造方法,默认的构造方法将不可用.

语法:

访问权限修饰符 类名(参数列表){
	对参数进行赋值即对成员变量赋值;
}

PS:绝对没有返回值,void也不行

方法名与类名相同

构造方法不用使用return关键字,但是使用了也不报错,不能返回任何返回值

构造方法在对象被创建时被调用

构造方法支持重载

访问权限修饰符支持public(公有)和private(私有),私有多用于单例模式

public class Teacher{
	String name;
	int age;
	//无参构造方法,关系到继承,可以对属性进行一些初始化赋值,可以对成员变量数组进行初始化
	public Teacher(){
		name = "张三";
		age = 18;
		System.out.println("无参构造方法被调用了");
	}
	public Teacher(String n,int a){
		name = n;
		age = a;
		System.out.println("有参构造方法被调用了");
	}
}

PS:只要提供构造方法,就提供两个------无参和有参

包
包的作用是为了管理java原文件使用

包有一个关键字package 用来创建包,在类的第一行

包名如何定义:
1.不能以java开头,因为java有安全机制,不允许使用,java开头的都是系统api
2.报名必须遵循标识符的命名规则,建议全部小写
3.企业开发中包名是公司域名的倒写,没有www
例如:www.qfedu.com–>com.qdedu 域名倒写

若公司域名有数字,在数字之前添加下划线如:com._123

公司域名倒写.项目名称.模块名是什么.子模块(组件)

类的复合
若在一个类中需要使用另外一个类属性或行为,可以将另外一个类作为当前类的属性(当前属性在整个类中使用)

若在一个类中需要使用另外一个类的属性或行为,可以在当前类的方法中将这个类作为参数

例:

/**
 * 设计一个猫类，猫具有属性（姓名，年龄，性别，铲屎官）和行为（吃，喝，卖萌）	
 * @author Administrator
 *
 */
public class Cat {
	String name;
	int age;
	char gander;
	Person ShitOfficer;//铲屎官
	public Cat() {
		
	}
	
	public Cat(String name,int age,char gander,Person ShitOfficer) {
		this.name = name;
		this.age = age;
		this.gander = gander;
		this.ShitOfficer = ShitOfficer;
	}
	public void eat() {
		System.out.println(this.ShitOfficer.name+"喂"+this.name+"吃");
		
	}
	public void drink(Person ShitOfficer;) {
		System.out.println(ShitOfficer.name+"喂"+this.name+"喝");
		
	}
	public void beingCute() {
		System.out.println(this.name+"给"+this.ShitOfficer.name+"卖萌");
		
	}
	
}

/**
 * 设计一个人类，人具有属性（姓名，年龄，性别）
 * @author Administrator
 *
 */
public class Person {
	
	String name;
	int age;
	char gander;
	
	public Person() {
		
	}
	public Person(String name,int age,char gander) {
		this.name = name;
		this.age = age;
		this.gander = gander;
	}
}

public class ObjectTest {

	public static void main(String[] args) {
		Person zhangsan = new Person("张三",20,'男');
		Cat cat = new Cat("Tom",3,'公',zhangsan);
		
		cat.eat();
		cat.beingCute();
		Person xiaohong= new Person("小红",18,'女');
		Cat cat1 = new Cat();
		cat1.name = "小白";
		cat.eat(xiaohong);
		
	}
}
/*运行结果
张三喂Tom吃
Tom给张三卖萌
小红喂小白喝
*/

封装

为了不让其他人操作成员变量,我们提供一种思想----封装
提供一种权限修饰符private(私有的)

属性私有化是封装的一种体现,但属性私有化不能代表封装

私有化的权限是最低的,仅限当前类能够访问

虽然私有化数据安全,问题是只能在内部访问,但其他类无法访问,无法操作------>过度封装

什么是封装

封装是面向对象三大特征之一,主要目的是为了将信息进行隐藏,把不需要外界知道的信息隐藏,尽可能实现隐藏功能实现的细节,向外部提供可以访问的方法,保证无法破坏原有方法内部的信息

在开发中,成员变量是不会对外提供访问的,因为成员变量对外访问之后,操作人员是可以随意更改的,所以提供一个权限修饰符private,不允许外部直接访问成员变量

private是私有化是封装概念的一种体现,但不能说private就是封装

这里提供了两个方法—>getter和setter
getter---->获取方法,获取成员变量的值
setter----->赋值方法,给成员变量赋值

//getter获取成员变量

语法:

//getter方法
访问权限修饰符 返回值类型 方法名(){
		return 对应成员变量;
}
访问权限修饰符:为了对外提供成员变量的值,几乎不用private修饰
都会使用public修饰

返回值类型:必须有返回值类型,获取那个成员变量的值,就是那个成员变量的数据类型

方法名:必须满足标识符命名规则,以get开头 get后面跟要访问的变量名
苏要注意boolean变量 get方法以 is开头

//setter方法
访问权限修饰符 void 方法名(参数){
		使用参数对成员变量进行赋值
}
访问权限修饰符:public
void 因为是多对成员变量赋值,没有返回值
方法名:setXXX
参数:对成员变量赋值,参数类型要与成员变量一致,参数名字也与成员变量一致
不需要return

public class Dog{
	private int age;
	public int getAge(){		//getter的定义
		return age;
	}	
	public void (int age){		//setter的定义
		if(age < 0){
			System.out.println("数据不合法,无法赋值");
			//还可以抛出异常
		}else{
			this.age = age;
		}
		
	}
}
//当前属性私有化之后只能通过getter方法获取或setter方法赋值
//不能直接操作变量
//getter和setter不用成对出现的

封装的好处:
1.使调用者更方便的正确方便的使用系统功能,防止调用者随意修改系统属性

2.提高组件的重用性

3.可以达到组件之间的低耦合性(当一个模块实现发生变化时,只要对外暴露的接口不变,就不会影响其他模块)