Java复习之路（第六天 面向对象 重载，类和对象 ）

Java基础

重载：方法的重载是指在一个类中定义多个重名的方法，a(int b)  a()   a(int c ,int d)   a(string name)

括号里面的类型，个数，顺序不同就会不同

但是要求每个方法具有不同的参数的列表（也就是说参数的个数和，类型不同）

程序调用方法时，可以通过传递给他们不同的个数和参数的类型来决定具体使用那一个方法

练习一：

数字求和，包括对方法的重写的要求

package com.tedu.overload;
//测试方法的重载
//1.方法名称相同，2.参数的列表不同
public class Test1_Overload {
	public static void main(String[] args) {
		method1();//调用无参数的类型
		method1(10);//调用有int参数的类型
		method1("刘晓坤");//调用有string参数的类型
		method1(2,3);//调用有双int参数的类型
	}
	private static void method1(int i, int j) {
		int sum;
		sum=i+j;
		System.out.println(sum);
	}
	private static void method1(String string) {
		System.out.println(string+"是个小可爱");
	}
	private static void method1(int i) {
		System.out.println(i);
	}
	//调用无参数的类型
	private static void method1() {
		System.out.println("我爱学习Java");
	}
}

（了解）二维数组

定义：存放数组的数组，也就是说数组里面存放的还是数组的数据的类型

动态创建：

int [] [] 2=new int [2][3],2代表的是外围数组的长度，3代表的是内围数组的长度

1.开辟空间存数据，外围数组的长度是2

2.开辟空间存数据，内围数组的长度是3

3.初始化数组，6个0

4.给数组分配内存，兵分配唯一的地址值

5.把地址值交给引用类型a来保存

静态创建：

int [ ][ ] a= { {1,2}  {2,3}  {3,4} }

遍历二维数组

方法:外边的遍历的就是外层的数组，里面的遍历就是内层的数组，

	private static void method1() {
		//创建动态的二维数组
		int [][]array=new int[2][3];
		//创建静态的二维数组
		int [][]array2= {{1,2},{3,4},{5,6}};
		for (int i = 0; i < array2.length; i++) {
			for (int j = 0; j < array2.length; j++) {
				System.out.println(array2[j][i]);
				//二维的数组不支持直接打印数组
				System.out.println(Arrays.toString(array2));
			}
		}
	}

调用方法进行排序：Arrays.sort(a);

//调用方法进行排序
public class Test666 {
	public static void main(String[] args) {
		int []a= {2,1,6,4,78,0};
		Arrays.sort(a);
		System.out.println(Arrays.toString(a));
	}
}

Arrays.copyOf(原数组，新的程度)

把数组复制成为一个指定长度的新的数组

新的数组的长度大于原数组，相当于复制，并且加位置

新的数组的长度小于原数组，相当于截取前一部分的数据

public class Test666 {
	public static void main(String[] args) {
		int []a= {2,1,6,4,78,0};
		//新数组长度大于原数组，相当于扩容
		int []NewA=Arrays.copyOf(a, 10);
		System.out.println(Arrays.toString(NewA));
		//新数组长度小于原数组，相当于缩容
		int []NewB=Arrays.copyOf(a, 2);
		System.out.println(Arrays.toString(NewB));
	}
}

面向对象（前言）

定义：所谓的面向对象是一种编程的思想，通过这种思想可以把生活中的复杂的事情比变得简单化，从原来的执行者变成了指挥者，这是基于面向过程的思想而言

三大特征：（重要）

封装性：就是把相关的数据封装成为一个类的组件

继承性：是子类自动的共享父类属性和方法，这是类之间的一种关系

多态：增强软件的灵活性和重要性

 

类和对象

类：定义

1.Java语言最基本单位就是类，类似于类型

2.类是一类事物的重新

3.可以理解为模板或者涉及图纸

 

对象：定义

每个对象具有三个特点：对象的状态，对象的行为和对象的标识

1.对象是状态用来描述对象的基本的特征

2.对象的行为用来描述对象的功能

3.对象的标识是指对象在内存中都有一个唯一的地址值用来和区别其他对象区分开

4.类是一类事物的抽象，对象是具体的实现

 

类和对象的关系

属性+方法

练习一：类的创建使用，通过new关键字创建对象

属性+行为的具体的含义，创建和使用，加上如何创建创建类和对象，包括创建类的方法（new 的方法 ）

package com.tedu.oop;
//测试创建类和创建对象
public class Test3_NewClass {
	public static void main(String[] args) {
		//通过new关键字，创建人类的对象，创建完类才能创建对象
		//这个P是引用的类型 ，引用Person对象的地址值
		Person person1=new Person();

                //修改属性的内容
		person1.name="熊大";
		person1.age=3;
		person1.gender="男";

		System.out.println(person1.name);
		System.out.println(person1.gender);
		System.out.println(person1.age);
		
		person1.eat();
		person1.sleep();
		
		
	}
}
//在一个Java文件的可以存在多个class
//只能有一个class别public修饰，而且文件名必须和public修饰的名称一致

//通过class关键字定义类（类是一类事物的抽象）

//创建的类，类值是一个框架
class Person{
	//属性（成员变量）+行为（成员方法）
	
	//属性（成员变量）
	String name;     //默认值是零
	String gender;
	int age;
	
	//行为（成员的方法）
	public void eat() {
		System.out.println("吃饭饭");

	}
	
	public void sleep() {
		System.out.println("睡觉觉");
	}
}

创建student类

包含属性：姓名name和学号no     包含学习study和复习review

创建student对象，重新设置属性的值并打印属性值和方法

package com.tedu.oop;
//创建student
public class Test4_student {
	public static void main(String[] args) {
		Student student=new Student();
		student.name="田学森";
		student.no=10;
		
		System.out.println(student.name);
		System.out.println(student.no);
		student.review();
		student.study();
	}
}

class Student{
	//创建姓名和学号
	String name;
	int no;
	
	//创建方法
	public void study() {
		System.out.println("我在学习");
	}
	public void review() {
		System.out.println("我在复习");
	}
}

 

对象在内存中的存储

Java把内存分为5大区域，我们重点关注栈和堆

1.一般来讲局部的变量存在栈中，方法完毕后就会被释放

2.对象（new 出来的东西）存放在堆中，对象不再被使用时，内存才会被释放

3.每个堆内的元素都有地址值

4.对象中的属性都有默认的值

 单一对象的内存图：

Person person=new Person();

1.在栈内存中开辟一个空间存放局部变量person

2.在堆内存中开辟一个空间存放Person对象

3.初始化Person对象的属性和方法，并把属性设置好默认值

4.给堆内存中的元素 分配内存空间，产生唯一的地址值

5.把对象的地址值交给引用变量person来保存

 

练习二：创建多个对象

栈：存储的特点,先进后出，先进来的压在栈底

 

引用变量：在此处的解释就是存放着其他变量的地址值，直接进行引用，从内粗里面直接进行寻找

 

封装

定义：封装就是指隐藏对象的属性和实现的细节，仅仅对外提供公共的访问的方式

好处：1.提高代码的安全性   2.提高重用性

private关键字：

是一个权限的修饰符号，用于修饰成员变量，成员函数/方法，被私有化的成员只可以在本类中进行访问

private修饰的类中的属性，可以利用get和set方法进行

提供公共的setXxx（）-- 设置属性值

   调用方法： student2.setAge(15);

    使用方法：public void setAge(int a) {
                         age=a;
                     }

提供公共的getXxx（）-- 设置属性值

package com.tedu.oop;
//进行封装学生类
public class Test6_Student {
	public static void main(String[] args) {
		Student2 student2 =new Student2();
		student2.name="王";
		System.out.println(student2.name);
		//age被私有化了，只能在本类中进行访问
		//4.调用set的方法，设置age属性的值
		student2.setAge(15);//age属性的值
		int age=student2.getAge();
		//5.获取属性的值
		System.out.println(age);
	}
}
//创建student2类
class Student2{
	String name;
	//1.被private修饰后，只能在本类中进行访问
	private int age;
	//修改age的属性的可见的范围
	//2.提供公共的setXxx（）-- 设置属性值
	public void setAge(int a) {
		//把age的属性重新设置成a的值
		age=a;
	}
	
	//3.提供公共的get（）--获取属性值
	public int getAge() {
		//通过return关键字，直接把age属性的值返回到调用的位置
		return age;
	}
	
	
}

练习：编写汽车类画内存图

私有化的属性：颜色，型号，品牌，价格

行为:开，飞。。。。。。

汽车对象的创建和使用