面向对象分析方法分析问题的思路和步骤：
1.根据问题需要，选择问题所针对的现实世界中的实体。
2.从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类。
3.把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。
4.将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。
1.Java 类及类的成员：属性、方法、构造器、代码块、内部类
2.面向对象的三大特征：封装、继承、多态性、(抽象性)
3.其它关键字：this、super、static、final、abstract、interface、package、import 等
（我们学pyhon的时候就是用一种面向过程的思想，Java则是面向对象，这里做一个区分。）
1.面向过程:强调的是功能行为，以函数为最小单位，考虑怎么做。
① 打开冰箱
② 把大象装进冰箱
③ 把冰箱门关住
2.面向对象:强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
* 人{
* 打开(冰箱){
* 冰箱.开门();
* }操作(大象){
* 大象.进入(冰箱);
* }关闭(冰箱){
* 冰箱.关门();
* }
* }
*
* 冰箱{
* 开门(){
* }
* 关门(){
* }
* }
*
* 大象{
* 进入(冰箱){
* }
* }
*/
面向对象的两个要素：
1.类:对一类事物的描述，是抽象的、概念上的定义，类中基本元素有属性和方法。
2.对象:是实际存在的该类事物的每个个体，因而也称为实例(instance)。可以理解为：类= 抽象概念的人；对象= 实实在在的某个人面向对象程序设计的重点是类的设计；设计类，其实就是设计类的成员。
创建类语法格式；
修饰符 class 类名{
属性声明;
方法声明;
}
创建对象语法：类名对象名= new 类名();
示例：
public class PersonTest {
public static void main(String[] args) {
//创建对象语法：类名对象名= new 类名();
Person p1 = new Person();
//调用类的结构：属性、方法
//调用属性:“对象.属性”
p1.name = "Tom";
p1.age = 25;
p1.isMale = true;
System.out.println(p1.name);
//调用方法:“对象.方法”
p1.eat();
p1.sleep();
p1.talk("chinese");
/
int sex;
public void study(){
System.out.println("studying");
}
public void showAge(){
System.out.println("age:" + age);
}
public int addAge(int i){
age += i;
return age;
}
}
测试类：
public class PersonTest {
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "Tom";
p1.age = 18;
p1.sex = 1;
p1.study();
p1.showAge();
int newAge = p1.addAge(2);
System.out.println(p1.name + "的年龄为" + newAge);
System.out.println(p1.age); //20
/
Student[] stus= new Student[5];
stus[0] = new Student();
sysout(stus[0].state);//1
sysout(stus[1]);//null
sysout(stus[1].number);//异常
stus[1] = new Student();
sysout(stus[1].number);//0
class Student{
int number;//学号
int state = 1;//年级
int score;//成绩
}
stus[0] = new Student();这里是创建匿名对象，既然是创建对象就会在堆空间再创建一套属性。
sysout(stus[1]);是null是因为第一行new了一个数组，数组的默认初始值是null。
public class ArrayUtil {
// 求数组的最大值
public int getMax(int[] arr) {
int maxValue = arr[0];
for (int i = 1; i < arr.length; i++) {
if (maxValue < arr[i]) {
maxValue = arr[i];
}
}
return maxValue;
}
// 求数组的最小值
public int getMin(int[] arr) {
int minValue = arr[0];
for (int i = 1; i < arr.length; i++) {
if (minValue > arr[i]) {
minValue = arr[i];
}
}
return minValue;
}
// 求数组总和
public int getSum(int[] arr) {
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum;
}
// 求数组平均值
public int getAvg(int[] arr) {
int avgValue = getSum(arr) / arr.length;
return avgValue;
}
// 反转数组
public void reverse(int[] arr) {
for (int i = 0; i < arr.length / 2; i++) {
int temp = arr[i];
arr[i] = arr[arr.length - i - 1];
arr[arr.length - i - 1] = temp;
}
}
// 复制数组
public int[] copy(int[] arr) {
int[] arr1 = new int[arr.length];
for (int i = 0; i < arr1.length; i++) {
arr1[i] = arr[i];
}
return null;
}
// 数组排序
public void sort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
// 遍历数组
public void print(int[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + ",");
}
System.out.println("]");
}
// 查找指定元素
public int getIndex(int[] arr, int dest) {
//线性查找
for (int i = 0; i < arr.length; i++) {
if (dest==arr[i]) {
return i;
}
}
return -1;
}
}
测试类：
public class ArrayUtilTest {
public static void main(String[] args) {
ArrayUtil util = new ArrayUtil();
int[] arr = new int[]{32,5,26,74,0,96,14,-98,25};
int max = util.getMax(arr);
System.out.println("最大值为:" + max);
// System.out.print("排序前:");
// util.print(arr);
//
// util.sort(arr);
// System.out.print("排序后:");
// util.print(arr);
System.out.println("查找:");
int index = util.getIndex(arr, 5);
if(index > 0){
System.out.println("找到了，索引地址:" + index);
}else{
System.out.println("没找到");
}
}
}
方法的重载
概念：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
“两同一不同”:同一个类、相同方法名，参数列表不同：参数个数不同，参数类型不同
举例：
// 举例一：Arrays类中重载的sort() / binarySearch()；PrintStream中的println()
// 举例二：
// 如下的4个方法构成了重载
public void getSum(int i,int j){
System.out.println("1");
}
public void getSum(double d1,double d2){
System.out.println("2");
}
public void getSum(String s ,int i){
System.out.println("3");
}
public void getSum(int i,String s){
System.out.println("4");
}
快速判断是否重载的方法：
严格按照定义判断：两同一不同。跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系！
JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量
public static void test(int a， String[] books);
JDK 5.0以后：采用可变个数形参来定义方法，传入多个同一类型变量
public static void test(int a， String … books);
可变个数形参的方法
具体使用：
1.可变个数形参的格式：数据类型 … 变量名
2.当调用可变个数形参的方法时，传入的参数的个数可以是：0个，1个，2个…
3.可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载。
4.可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。即二者不可共存。
5.可变个数形参在方法中的形参中,必须声明在末尾。
6.可变个数形参在方法中的形参中，最多只能声明一个可变形参。
public class MethodArgs {
public static void main(String[] args) {
MethodArgs test = new MethodArgs();
test.show(12);
test.show(new String[] { "AA", "BB", "CC" });
}
public void show(int i) {
}
public void show(String... strs) {
System.out.println("show(String ...strs)");
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);
}
}
// 此方法与上一方法不可共存
// public void show(String[] strs){
//
// }
//就是这个可变参数如果放在前面，在调用的时候就不知道哪个是可变参数哪个不是。
public void show(int i, String... strs) {
}
//The variable argument type String of the method show must be the last parameter
// public void show(String... strs,int i,) {
}
}
Java的值传递机制
规则： (重点)
如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
public class ValueTransferTest {
public static void main(String[] args) {
System.out.println("**********基本数据类型：***********");
int m = 10;
int n = m;
System.out.println("m = " + m + ", n = " + n);
n = 20;
System.out.println("m = " + m + ", n = " + n);//m = 10, n = 20
System.out.println("***********引用数据类型:********");
Order o1 = new Order();
o1.orderId = 1001;
Order o2 = o1; //赋值后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " + o2.orderId);
//o1.orderId = 1001,o2.orderId = 1001
o2.orderId = 1002;
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " + o2.orderId);
//o1.orderId = 1002,o2.orderId = 1002
}
}
class Order{
int orderId;
}
针对基本数据类型
方法的形参的传递机制：值传递
1.形参：方法定义时，声明的小括号内的参数
实参：方法调用时，实际传递给形参的数据
2.值传递机制：
如果参数是基本数据类型，此时实参赋值给形参的是实参真是存储的数据值。（其实还是遵循上面那个规则）
示例：
public class ValueTransferTest1 {
public static void main(String[] args) {
int m = 10;
int n = 20;
System.out.println("m = " + m + ", n = " + n);
//m = 10, n = 20
ValueTransferTest1 test = new ValueTransferTest1();
test.swap(m, n);
System.out.println("m = " + m + ", n = " + n);
//m = 10, n = 20
}
public void swap(int m,int n){
int temp = m;
m = n;
n = temp;
}
}
因为只是传了一个数值给局部变量，交换也只是在swap中交换，局部变量储存在栈中，换完值之后就出栈了，所以并没有换成功。
针对引用数据类型如果参数是引用数据类型，此时实参赋值给形参的是实参存储数据的地址值。
public class ValueTransferTest2 {
public static void main(String[] args) {
Data data = new Data();
data.m = 10;
data.n = 20;
System.out.println("m = " + data.m + ", n = " + data.n);
ValueTransferTest2 test = new ValueTransferTest2();
test.swap(data);
System.out.println("m = " + data.m + ", n = " + data.n);
//m = 20, n = 10
}
public void swap(Data data){
int temp = data.m;
data.m = data.n;
data.n = temp;
}
}
class Data{
int m;
int n;
}
练习1
public class TransferTest3{
public static void main(String args[]){
TransferTest3 test=new TransferTest3();
test.first();
}
public void first(){
int i=5;
Value v=new Value();
v.i=25;
second(v,i);
System.out.println(v.i);
}
public void second(Value v,int i){
i=0;
v.i=20;
Value val=new Value();
v=val;
System.out.println(v.i+" "+i);
}
}
class Value {
int i= 15;
}
两个Value v=new Value();new出来的i：初始都是零，然后才被属性赋值，所以一开始是0然后划掉。 这种画个内存图就很好理解。
public static void method(int a,int b){
a = a * 10;
b = b * 20;
System.out.println(a);
System.out.println(b);
System.exit(0);
}
直接在方法里输出局部变量，外面的成员变量只是传了个数值进来，exit(0)是直接退出程序的意思不再向下面运行。
练习3微软：
定义一个int型的数组：int[] arr = new int[]{12,3,3,34,56,77,432};让数组的每个位置上的值去除以首位置的元素，得到的结果，作为该位置上的新值。遍历新的数组。
for(int i = arr.length –1;i >= 0;i--){
arr[i] = arr[i] / arr[0];
}
不能正着遍历是因为在i = 0时，首个元素已经变成1并且储存进去了，所以就会出错，要么倒着遍历要么从第二个元素开始，最后再除第一个元素。还可以用一个变量代替首个元素。
int temp = arr[0];
for(int i= 0;i < arr.length;i++){
arr[i] = arr[i] / temp;
}
练习4
public class ArrayPrint {
public static void main(String[] args) {
int[] arr = new int[]{1,2,3};
//传进去的是一个Object的对象
System.out.println(arr);//地址值
char[] arr1 = new char[]{'a','b','c'};
//传进去的是一个数组，里面遍历数据了
System.out.println(arr1);//abc
}
}
我们知道println是一系列重载的方法，当输入一个整型数组时，传的是Object类型，它是万用类，它底下有个toString方法，当我们输出一个对象的引用时，实际上就是调用当前对象的toString()。
Object类中toString()的定义：
源码：
public String toString() {undefined
return getClass().getName() + “@” + Integer.toHexString(hashCode());
}
从源码中可以看到它返回的是数组的hashCode
而当你输入char类型数组时，它调的这个方法就是自动帮你遍历数组。
public class Circle {
double radius; //半径
//返回圆的面积
public double findArea(){
return radius * radius * Math.PI;
}
}
定义一个PassObject类
public class PassObject {
public static void main(String[] args) {
PassObject test = new PassObject();
Circle c = new Circle();
test.printAreas(c, 5);
System.out.println("no radius is:" + c.radius);
}
public void printAreas(Circle c,int time){
System.out.println("RadiusttAreas");
//设置圆的半径
for(int i = 1;i <= time ;i++){
c.radius = i;
System.out.println(c.radius + "tt" + c.findArea());
}
//重新赋值
c.radius = time + 1;
}
}
