方法、数组、面向对象!

一.方法

1.什么是方法

方法就是用功能代码块{}将核心代码包起来,并为之取一个名字.

2.方法的定义

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

/*
·修饰符:修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。

·返回值类型:方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。

·方法名:是方法的实际名称。方法名和参数表共同构成方法签名。

·参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

·方法体：方法体包含具体的语句，定义该方法的功能。
*/

3.方法的调用

1)当方法返回一个值的时候，方法调用通常被当做一个值。

2)如果方法返回值是void，方法调用一定是一条语句。例如，方法println返回void。

public class TestMax {
   /** 主方法 */
   public static void main(String[] args) {
      int i = 5;
      int j = 2;
      int k = max(i, j);
      System.out.println( i + " 和 " + j + " 比较，最大值是：" + k);
   }

   /** 返回两个整数变量较大的值 */
   public static int max(int num1, int num2) {
      int result;
      if (num1 > num2)
         result = num1;
      else
         result = num2;

      return result; 
   }
}

4.方法的重载

多个方法名相同,参数列表不同,与返回值无关

public static double max(double num1, double num2) {
  if (num1 > num2)
    return num1;
  else
    return num2;
}

二.数组

1.Java 语言中提供的数组是用来存储固定大小的同类型元素。

2.数组的定义格式

        1)数据类型[] 数组名称 ;

        2)数据类型  数组名称[] ;

3.数组的创建

        数据类型[] 数组名称 = new 数据类型[长度] ;

4.数组的应用

public class TestArray {
   public static void main(String[] args) {
      // 数组大小
      int size = 10;
      // 定义数组
      double[] myList = new double[size];
      myList[0] = 5.6;
      myList[1] = 4.5;
      myList[2] = 3.3;
      myList[3] = 13.2;
      myList[4] = 4.0;
      myList[5] = 34.33;
      myList[6] = 34.0;
      myList[7] = 45.45;
      myList[8] = 99.993;
      myList[9] = 11123;
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < size; i++) {
         total += myList[i];
      }
      System.out.println("总和为： " + total);
   }
}

5.数组的排序---冒泡排序

class Test{
    public static void main(String args){
        int[] arr = {3,6,5,8,9,2,7,1};
        maoPao(arr) ;
        print(arr) ;
    }
    public static void maoPao(int[] arr){
        for(int x = 0 ; x < arr.length-1 ; x++){
            for(int y = 0 ; y < arr.length-1-x ; y++){
                if(arr[y] >arr[y+1]){
                    int temp = arr[y] ;
                    arr[y] = arr[y+1] ;
                    arr[y+1] = temp ;
                }
            }
        }
    }

    public static void print(int[] arr){
        System.out.println("[") ;
        for(int x = 0 ; x < arr.length ; x++){
            if(x == arr.length-1){
                System.out.println(arr[x] + "]");
            }else{
                System.out.println(arr[x] + ",");
            }
        }
    }
}

三.面向对象

1.对象与类

对象:  对象是类的一个实例,有状态和行为.

类：类是一个模板，它描述一类对象的行为和状态。

2.类的类型变量

• 局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
• 成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
• 类变量：类变量也声明在类中，方法体之外，但必须声明为static类型.

  3.局部变量和成员变量的区别

        1)在类中的书写位置区别
            局部变量:在方法定义中或者是方法声明上;
            成员变量:在类中,方法外;
        2)在内存中的位置不同
            局部变量:在栈内存中
            成员变量:在堆内存中
        3)生命周期不同:
            局部变量:随着方法调用而存在,随着方法调用结束而消失
            成员变量:随着对象的创建而存在,随着对象的调用完毕,等待垃圾回收器空闲时候回收,不会              立即消失!
        4)初始化时机不同:
            局部变量:要么先定义,使用之前必须初始化;要么直接初始化
            成员变量:  可以不赋值,系统默认对成员变量初始化    也可以通过对象名.成员变量 =赋值;  

4.创建对象

对象是根据类创建的。在Java中，使用关键字new来创建一个新的对象。创建对象需要以下三步：

• 声明：声明一个对象，包括对象名称和对象类型。
• 实例化：使用关键字new来创建一个对象。
• 初始化：使用new创建对象时，会调用构造方法初始化对象。

public class Dog{

   public Dog(String name){
      //这个构造器仅有一个参数：name
      System.out.println("小狗的名字是 : " + name ); 
   }

   public static void main(String[] args){
      // 下面的语句将创建一个Foo对象
      Dog dog = new Dog("tommy");
   }

}

    5.面向对象的实例

/*
	描述一个手机事物
		属性:品牌,价格,颜色,内存
		行为:打电话/发短信/玩游戏
		
	定义一个类来描述 :手机类 Phone
				成员变量:brand,price,color,memory
				成员方法:callPhone(xx),sendMsg(xx),playGame(xx)
*/
//定义手机类
class Phone{
	//成员变量
	String brand ;//品牌
	int price ;//价格
	String color ;//机身颜色
	int memory ;//内存
	
	//成员方法
	public String callPhone(String toName){
		return "可以给"+toName+"打电话了" ;
	}
	
	public void sendMsg(String name){
		System.out.println("可以给"+name+"发短信了...") ;
	}
	public void playGame(String gameName){//游戏名称
		System.out.println("使用手机可以玩"+gameName) ;
	}
	
	
}

//测试类
class PhoneTest{
	public static void main(String[] args){
		//创建一个手机类对象
		//类名 对象名 = new 类名() ;
		Phone p = new  Phone() ;
		System.out.println(p) ; //Phone@6d06d69c 地址值
		System.out.println(p.brand+"---"+p.price+"---"+p.color+"---"+p.memory) ;
		//成员变量赋值
		p.brand = "华为p40保时捷版" ;
		p.price = 14999;
		p.color = "翡翠绿" ;
		p.memory = 256 ;
		System.out.println(p.brand+"---"+p.price+"---"+p.color+"---"+p.memory) ;
		String result = p.callPhone("父母") ;
		System.out.println("result:"+result) ;
		p.sendMsg("女朋友") ;
		p.playGame("csgo") ;
		
	}
}

  6.构造方法   

        1)构造方法是一种特殊的方法,方法名和类名一致;

        2)构造方法的特点:  ①方法名和类名一致;
           ②构造方法没有返回值类型
           ③连void都没有 

        3)构造方法的分类:无参构造方法和有参构造方法

四.面向对象之封装

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

2.封装的优点

• 良好的封装能够减少耦合。
• 类内部的结构可以自由修改。
• 可以对成员变量进行更精确的控制。
• 隐藏信息，实现细节

3.封装的实例

public class EncapTest{

   private String name;
   private String idNum;
   private int age;

   public int getAge(){
      return age;
   }

   public String getName(){
      return name;
   }

   public String getIdNum(){
      return idNum;
   }

   public void setAge( int newAge){
      age = newAge;
   }

   public void setName(String newName){
      name = newName;
   }

   public void setIdNum( String newId){
      idNum = newId;
   }
}

五.一个标准类的书写

/*
	使用学生类描述学生事物,并且进行测试
	
		学生事物的属性
				姓名,年龄,性别
		学生事物的行为:
				学习,玩游戏
		
		
	定义学生类
			成员变量:私有化
						name,age,gender
			构造方法:
					无参/有参构造方法
			成员方法:
					setXXX(xx),getXXX()
					study(),playGame()
		
*/
class Student{
	//成员变量私有化
	private String name ;//姓名
	private int age ; //年龄
	private String gender ; //性别
	
	//无参构造方法
	public Student(){
		
	}
	
	//有参构造方法
	public Student(String name,int age,String gender){
		this.name = name ;
		this.age  = age ;
		this.gender = gender ;
	}
	
	//对外的公共访问方法setXXX(xx)/getXXX()
	public void setName(String name){
		this.name = name ;
	}
	public String getName(){
		return name ;//获取学生姓名
	}
	public void setAge(int age){
		this.age = age ; //给学生年龄赋值
	}
	public int getAge(){
		return age ; //获取学生年龄
	}
	
	public void setGender(String gender){
		this.gender = gender ;//给学生性别赋值
	}
	public String getGender(){
		return gender ;//获取学生的性别
	}
	
	//其他的成员方法
	public void study(){
		System.out.println("正在学习面向对象之标准类的写法...") ;
	}
	public void playGame(String gameName){
		System.out.println("学习困了,可以玩一把"+gameName+",在楼下玩") ;
	}
}

//测试类
class StudentTest{
	public static void main(String[] args){
		
		//方式1:测试  
		//无参构造方法+setXXX(xx)/getXXX()
		//创建学生类对象
		Student s = new Student() ;
		s.setName("张三") ;
		s.setAge(23) ;
		s.setGender("男") ;
		System.out.println("该学生的姓名是"+s.getName()+
		",年龄是:"+s.getAge()+",性别为:"+s.getGender()) ;
		
		s.study() ;
		s.playGame("王者农药") ;
		
		System.out.println("---------------------------------------") ;
		
		//方式2:测试
		//有参构造方法+getXXX()
		Student s2 = new Student("李四",22,"女") ;
		System.out.println("该学生的姓名是"+s2.getName()+
		",年龄是:"+s2.getAge()+",性别为:"+s2.getGender()) ;
		
		s2.study() ;
		s2.playGame("吃鸡") ;
	}
}