Java基础之方法、数组、面向对象

方法：完成特定功能的代码块；
        方法的格式：
public static 返回值 方法名(参数类型1 变量1,参数类型2 变量名){
return ...
}        方法的解释：public static：方法是静态的,并且是公共的方法 (今天写方法,public static)；
返回值(数据类型)： 根据具体的需求,返回什么类型,用什么样的数据类型结束；
方法名：给当前代码块起名字,命名规则:单个单词:字母全小写 多个单词:第一个单词全部小写,第二个单词开始每个单词首字母大写；
return：将当前代码的计算的结果,返回给调用者；        方法调用：

1)单独调用：
        单独调用,没有意义,没有输出结果；
2)输出调用：
        直接输出了结果,写死了,不能对结果进行操作；
3)赋值调用：有返回值类型的方法,推荐使用赋值调用,它可以结果进一步操作；
        int result = sum(a,b) ;

        定义一个方法的注意事项：

    1)方法和方法是平级关系,一个方法中不能再定义个方法
    2)定义一个方法 时候,形式参数必须有数据类型,否则有问题
    3)在主main()中,调用方法的时候,实际参数中不需要带数据类型的
    4)有大括号的地方,不能有分号,有分号的地方不能有大括号

        举例：

package org.westos.g_function;

import java.util.Scanner;

/**
* 键盘录入行数和列数,在控制台输出对应的*形
* @author Administrator
*
*/
public class FunctionTest4 {

public static void main(String[] args) {

//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;

//接收数据
System.out.println("请输入一个行数:");
int x = sc.nextInt() ;

System.out.println("请输入一个列数:");
int y = sc.nextInt() ;

//调用
print(x,y) ;

}

/**
* 两个明确
* 	1)返回值类型:没有具体的返回值:void
* 	2)明确参数类型:2个参数 分别int
* */
public static void print(int a,int b) {  //a ,b
for(int x = 0 ; x < a ; x ++) {
for(int y = 0 ; y < b ; y++) {
System.out.print("*");
}
System.out.println();
}
}
}

数组：可以存储多个元素并且多个元素是同一种类型的容器；
        数组的定义：
                数据类型[] 数组名;
数据类型 数组名[];
         举例:
int[] a; 定义了一个int类型的数组变量a
int a[] ;       定义了一个int类型 变量a数组
                这两种方式的定义:虽然写法不一样,并且读法不一样,但是表达的效果一样,都是在定义一个数组,推荐使用第一种方式;
        数组的初始化:
1)动态初始化:  给数组指定长度,数组中的元素值由系统默认给定
2)静态初始化:  给定数组中元素的值,数组的长度由系统给定;    
                动态初始化:
         数据类型[] 数组名 = new 数据类型[数组长度] ;
                         举例:
                int[] arr = new int[3] ;
                数组的静态初始化:
        指定数组的元素,长度由系统给定
                        定义个数:
                        原始格式:
                数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3....} ;
                        简写方式:
                数据类型[] 数组名称= {元素1,元素2,元素3..} ; 
                        举例:
                int[] arr = new int[]{1,2,3} ;
                int[] arr = {1,2,3} ;
                        这种方式错误：动静结合  定义数组要么动态初始化,指定长度,要么静态初始化指定数组元素!
                int[] arr2 = new int[3]{1,2,3} ;
        数组中经常会出现的异常:
ArrayIndexOutOfBoundsException:数组角标越界异常
出现的原因：访问了数组中不存在的索引值;
解决方案：观察数组中到底有索引值到多少;  数组长度-1
NullPointerException:空指针异常 (在实际开发中该异常是最多的)
出现的原因：对象为null,而开发者还要去使用对象,就会出现问题
解决方案：给某个对象进行非空判断,防止程序程序空指针异常
                对于异常:
        把从头到尾,将遇见到的异常建立文档；
出现该异常的原因；
如何解决异常；
        举例：
package org.westos.array;
/**
* 数组中的应用:
* 给定一个数组,静态初始化的,遍历这个数组;
* @author Administrator
*
*/
public class ArrayTest {

public static void main(String[] args) {

//定义数组,静态初始化
int[] arr = {11,22,33,44,55} ;

/**
* 获取数组中的元素值,通过数组名称[索引]获取
*/
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);

System.out.println("----------------------");

//遇见这种重复性高的代码,可以采用for循环 :循环的思想
for(int x = 0 ; x < 5 ; x ++) {
System.out.println(arr[x]);
}

System.out.println("----------------------");

int[] arr2 = {11,22,33,44,56,78,23,10,20,30} ;
//如果数组中的元素非常多,数元素个数非常麻烦
/**
* 针对这种情况,Java提供数组的属性:lenth属性
* 获取数组中的长度
*/
System.out.println(arr.length);
System.out.println(arr2.length);
System.out.println("----------------------");

//将上述代码继续改进,使用数组的长度进行操作
for(int x = 0 ;x < arr.length ; x ++) {
System.out.println(arr[x]);
}

//继续改进:学习方法,所以将遍历的功能写成一个独立的代码块
//调用
printArray(arr2);
System.out.println("------------------------");
printArray(arr) ;

System.out.println("------------------------");
//遍历数组之后:[11, 22, 33, 44, 55]
printArray2(arr);
printArray2(arr2);
}
/**
* 定义方法:两个明确
* 1)返回值类型: 没有具体返回值:void
* 2)参数类型:int类型数组
*
*/
public static void printArray(int[] arr) {
for(int x = 0 ; x < arr.length ; x ++) {
System.out.println(arr[x]);
}
}

//最终改进:
public static void printArray2(int[] arr) {
//左中括号
System.out.print("[");
for(int x = 0 ; x < arr.length ; x ++) {
//判断当前x是否是最后一个索引
if(x==arr.length-1) {//如果是最后一个索引的对应的元素
System.out.println(arr[x]+"]");
}else {
System.out.print(arr[x]+", ");
}
}
}
}

面向对象：
        讲面向对象之前:
        面向过程:
        假设有一个需求:求数组中的最大值;
        定义一个数组,静态初始化---->定义一个参照物---->遍历....
        给一个需求,对需求分析,然后一步一步进行操作,最终得到某一个结果,整个过程都是自己在完成....

        面向对象的思想概述:
思想的特征:
1)面向对象更符合我们的生活中的行为思想习惯
2)面向对象将我们从执行者变成了指挥者,指挥对象做事情
3)面向对象简单性体现在这里:让我们事情从复杂性--->简单化

举例：洗衣服:
    面向过程：脱下脏衣服--->放到一个盆里面--->加水,洗衣液---->泡一泡--->搓一搓---->拧一拧----->晾一晾
    面向对象：脱下脏衣服--->放到一个全自动洗衣机中--->一键---->晾一晾
炒菜:
    面向过程：买菜--->摘菜--->洗菜--->切菜--->炒菜--->出锅
    面向对象：找一个对象..--->出锅...
        举例:

把大象装进冰箱
1)装大象的方法in()
2)开冰箱门:open()
3)关闭冰箱门:close()
面向过程:
class Test{
main(..){
//分别调用三个方法
open();
in();
close();
}

//开冰箱门
public static void open(){
System.out.println("开冰箱门...") ;
}
//装大象
public static void in(){
System.out.println("把大象塞进冰箱") ;
}

//关闭冰箱门
public static void close(){
System.out.println("开冰箱门...") ;
}
}

面向对象:
把大象装进冰箱 :   名词提取法:  大象类,冰箱类,测试类

class 大象类{
public static void in(){
System.out.println("把大象塞进冰箱") ;
}
}

class 冰箱类{
public static void open(){
System.out.println("开冰箱门...") ;
}

public  static  void close(){
System.out.println("开冰箱门...") ;
}
}

class Test{
main(){
类名.方法名() ;
大象类.in() ;
冰箱类.open();
并迅雷.close() ;
}
}

        面向对象的三大特征:
    封装；    继承；    多态；

        万物皆对象...

        学习编程语言，就是为了模拟现实世界的事物；

        面向对象语言中现实世界的事物在代码中如何体现的；

学生
属性:姓名 年龄 性别 ...学号
行为:学习,打游戏....

        学生现实世界的事物------>代码       学生类:Student
        属性:属性:姓名 年龄 性别 ...学号 成员变量:name,age,sex...
        行为:学习,打游戏.... 成员方法:study(),playGame();

总结:
面向对象
:将事物看成XX类,将事物对应的属性--->看成这个类的成员变量

将事物对应的行为----->看成这个类的成员方法

        //属性看成成员变量，行为看成成员方法；
                描述一个学生事物,
        属性:姓名,年龄,性别,学号
        行为:学习
                在Java中,创建对象:new对象
                        类名 对象名 = new 类名() ;
        举例：
package org.westos.面向对象练习;

import java.util.Scanner;

/**
* 需求:有一个长方形,宽度和高度可以键盘录入,求长方形的周长和面积
* 然后在测试类Test2类中进行测试
*
* 分析:
* 定义一个长方形类
* 成员变量:宽度和高度
* 成员方法:求周长和面积
* @author Administrator
*
*/
//定义一个长方形类
class ChangFangXing{
//定义成员变量
private int width ;
private int length ;

//无参构造
public ChangFangXing() {

}

//只需要提供setXXX()公共方法
public void setWidth(int width) {
this.width = width ;
}
public void setLength(int length) {
this.length = length ;
}

//周长
public int zhouChang() {
return (width+length) *2 ;
}

//面积
public int getArea() {
return length * width ;
}
}

//测试类
public class Test2 {

public static void main(String[] args) {

//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;

//接收数据
System.out.println("请输入长方形的长:");
int length = sc.nextInt() ;

System.out.println("请输入长方形的宽:");
int width = sc.nextInt() ;

//创建ChangFangXing类的对象
ChangFangXing cfx = new ChangFangXing() ;

//进行赋值
cfx.setWidth(width);
cfx.setLength(length);

System.out.println("长方形的周长是:"+cfx.zhouChang());

System.out.println("长放形的面积是: "+cfx.getArea());

}

}