java学习总结3

什么是方法?
    就是使用功能代码块{}(代码块)将核心功能使用{}包起来,并为之起一个名字(符号标识符的规则)即可!

Java中方法的定义格式:
    分两种情况:
        1)有具体返回值类型的方法定义
        2)没有具体返回值类型的方法定义

    1)有具体返回值类型的方法定义
     固定格式:
        权限修饰符 static  返回值类型 方法名(形式参数类型1 变量名1,形式参数类型2 变量2....){
            //功能业务操作
            return 结果;
        }

        解释:
            权限修饰符:现在方法访问权限:公共的/公开的,访问权限足够大,例如:public
            static:面向对象在讲,目前来说必须带上static
            返回值类型:数据类型 (目前使用的基本类型)
            方法名:见名知意,满足标识符的规则...(小驼峰命名法)
            形式参数类型:数据类型(目前使用的基本类型)
            变量名:定义参数名称 (见名知意)满足标识符的规则...(小驼峰命名法)

            有具体返回值类型的方法调用
            方法名(实际参数) ;
            1)单独调用:没有输出
            2)输出调用:可以用,不建议用,因为如果需要将结果进一步操作,写死,不太好!
            3)赋值调用:推荐

            有返回值类型方法调用:赋值调用
    
            返回值类型 变量名  = 方法名(实际参数名1,实际参数名2....);
            使用变量名即可.

            例: 求两个数据之和,使用方法来完成!

class FunctionDemo1{
	public static void main(String[] args){ //能够jvm识别调用,程序的入口
		
		//实际参数:可以键盘录入/也可以直接定义
		
		//定义两个变量
		int a = 10 ;
		int b = 20 ;
		
		//1)单独调用
		//add(a,b) ; 没有输出结果
		
		//2)输出调用:可以用,不建议用,因为如果需要将结果进一步操作,写死,不太好!
		//System.out.println("两个数据之和是:"+add(a,b)) ;
		
		//3)赋值调用:推荐
		int result = add(a,b) ;
		System.out.println("两个数据之和是:"+result);
 		
	}
	public static int add(int a,int b){
		//功能业务操作
		int c = a+ b;
		return c ;

	}
}

    Java中定义方法和调用方法的注意事项(有返回值类型的方法)
    
        1)方法和方法是平级关系,在一个方法中不能嵌套定义另一个方法
        2)Java是一个强类型语言,定义方法的时候,形式参数类型必须携带,不能省略.
        3)调用方法的时候,实际参数不需要携带数据类型的        
        4)定义方法的时候,后面不能有分号,这个方法缺少方法主体的,没有意义.
                有{左大括号的地方不能有分号;
                有;号的地方不能有{左大括号
        public static int add(int a,int b);
        {   没有意义
            return a + b ;
        }

    按照方法的定义格式:
        固定格式: 权限修饰符 静态修饰符static  返回值类型 方法名(形式参数列表...){
            ..
        }
        "直接在控制台打印数据"
        没有具体返回值,Java有一个规定,遵循上面方法定义格式,使用关键字void 代替了返回值类型(只是为了填充语法格式)
        public static void main(String[] args){}
        没有具体返回值类型方法定义格式:

        固定写法
        public static void 方法名(参数类型1 变量名1,参数类型2 变量名2....){
            输出语句/或者数据交换...
        }
        
        没有具体返回值类型方法调用:
        1)单独调用:推荐!
            方法名(实际参数列表) ;
        2)输出调用:不行
        3)赋值调用:不行

class FunctionDemo2{
	public static void main(String[] args){
		//for循环嵌套:
		//外层for:控制行数
		//内层for:控制列数
		for(int x  = 0 ; x < 4 ; x ++){//控制行数
			for(int y = 0 ; y < 5 ; y ++){//控制列数
				System.out.print("*") ;
			}
			System.out.println() ;
		}
		System.out.println("-------------------------------------------") ;

		//将上面封装到代码块中
		//单独调用
		System.out.println("-------------------------------------------") ;
		printXing(4,5) ;
		System.out.println("-------------------------------------------") ;
		printXing(5,6) ;
		System.out.println("-------------------------------------------") ;
		printXing(7,8) ;
		
		
	}
	//套格式去使用
	public static void printXing(int m,int n){//m:行,n:列
		for(int x  = 0 ; x  
  1.3  方法重载 
方法重载:
         多个方法名相同,参数列表不同,与返回值无关
                         参数列表不同:
                             1)参数个数不同
                             2)参数类型不同
                             3)考虑类型顺序
                             public static int sum(double a,int b){}
                             public static int sum(double a,int b,int c){}
                             public static double sum(int  a,double b){}
                             public static float sum(float a,float b){}
                             public static float Sum(float a,float b){} :不是重载
         方法重载的目的:就是为了让这个功能扩展性更多;方法中接收常用的一些数据类型参数
 
class FunctionDemo3{
	public static void main(String[] args){
		
		//分别测试:
		//调用两个数据之和的方法
		System.out.println(sum(10,20)) ;
		//System.out.println(sum2(10,20,30)) ; 
		//System.out.println(sum3(10,20,30,40)) ;
		//System.out.println(sum4(10.11,1.34)) ;
		
		System.out.println(sum(10,20,30)) ; 
		System.out.println(sum(10,20,30,40)) ;
		System.out.println(sum(10.11,1.34)) ;
	}

	public static int sum(int a,int b) {
		return a + b;
	}
	
	//定义三个数据之和的方法
	//public static int sum2(int a,int b,int c){
	//改进之后:按照方法重载的概念
	public static int sum(int a,int b,int c){
		return a + b + c ;
	}
	
	//定义四个数据之和的方法
	//public static int sum3(int a,int b,int c,int d){
	//改进
	public static int sum(int a,int b,int c,int d){	
		return a + b + c + d;
	}
	
	//public static double sum4(double a,double b){
	public static double sum(double a,double b){	
		return a + b ;
	}
	
}
 
2.数组 
定义:是只能够存储同一种类型的容器,在同一数组中,元素的数据类型必须一致.
 格式:数据类型[] 数组名称;    数据类型 数组名称[];
 初始化:动态初始化和静态初始化
 
  2.1 动态初始化 
                我们给定数组的长度,元素由系统(Jvm)默认初始化
                 1) 数据类型[] 数组名称 = new 数据类型[长度] ; 推荐第一种
                 2) 数据类型 数组名称[] = new 数据类型[长度] ;
 
                创建一个数组对象
                         int[] arr = new int[3] ;
                         int arr[] = new int[3] ;
 
class ArrayDemo{
	public static void main(String[] args){
			//创建一个数组:动态初始化
			
			//数据类型[] 数组名称 = new 数据类型[长度] ;
			int[] arr = new int[3] ;//jvm系统默认对3个初始化
			
			
			System.out.println(arr) ; //I@6d06d69c :地址值
			System.out.println("-----------------------") ;
			
			//数组名称[索引值]:索引值从0开始 
			//默认初始化
			System.out.println(arr[0]) ;//访问数组第一个元素  0
			System.out.println(arr[1]) ;//访问数组第二个元素  0
			System.out.println(arr[2]) ;//访问数组第三个元素  0
			System.out.println("-----------------------") ;
			
			arr[0] = 10 ;
			arr[1] = 20 ;
			arr[2] = 50 ;
			System.out.println(arr[0]) ;//访问数组第一个元素  10
			System.out.println(arr[1]) ;//访问数组第二个元素  20
			System.out.println(arr[2]) ;//访问数组第三个元素  50

	}
}
 
  2.2  静态初始化 
        我们给出具体的元素内容,系统默认分配长度
                 数据类型[] 数组名称 = new int[]{元素1,元素2,元素3,.....} ; 推荐第一种
                 数据类型 数组名称[] = new int[]{元素1,元素2,元素3,.....} ;
                 简化格式:书写代码简单
                     数据类型[] 数组名称 = {元素1,元素2,元素3,.....} ;
                     数据类型 数组名称[] = {元素1,元素2,元素3,.....} ;
                 举例:
                     int[] arr = new int[]{1,2,3,4,5,6} ;
                     简化格式:
                     int[] arr = {1,2,3,4,5,6} ;

                 注意事项:
                     数组的初始化:要么动态初始化/要么静态初始化,不能"动静结合"
 
class ArrayDemo4{
	public static void main(String[] args){
		//创建一个数组,静态初始化
		//错误的写法:动静结合
		//int[] arr = new int[3]{1,2,3} ;
		
		int[] arr = {11,22,33,44,55} ;
		
		System.out.println(arr) ;
		System.out.println(arr[0]) ;
		System.out.println(arr[1]) ;
		System.out.println(arr[2]) ;
		System.out.println(arr[3]) ;
		
	}
}
 
  2.3  数组中的异常 
   1)编译时期的异常:jvm检查语法不通过语法格式存在问题
    2)运行时期异常:开发者:代码书写不严谨导致的问题.
        java.lang.ArrayIndexOutOfBoundsException:数组角标越界异常
         出现的原因:访问了数组中不存在的角标(索引值)
         如何解决:检查代码,更改索引值
         java.lang.NullPointerException:空指针异常
         引用类型的默认值都是null;
         String s = null ;  字符串是一种特殊的引用类型
         出现的原因:某一个对象已经为空了,null(没有堆内存地址),这个时候还要去访问元      素或者调用
         这个对象的方法,那么就出现空指针;
         如何解决:
             使用逻辑判断语句,对该对象进行非空判断.
 
  2.4 应用 
   2.4.1 数组的遍历 
        就是元素内容一一获取出来,使用它完成需求!
 
	public static void printArray(int[] arr){
		//先输出"["
		System.out.print("[") ;
		//遍历这个arr数组
		for(int x = 0 ; x < arr.length ; x++){
			//判断:如果当前x的取值:取到了arr.length-1:数组的最大索引值
			if(x==arr.length-1){
				//最后一个元素以及"]"
				System.out.println(arr[x]+"]") ;
				
			}else{
				//不是最后一个元素,中间的元素
				System.out.print(arr[x]+", ") ;
			}
		}
	}
 
   2.4.2 求最大值或者最小值        
    分析:
         1)创建一个数组,静态初始化
         获取数组中的最大值的思路
         2)定义参照物:假设思想
         将数组中的第一个元素作为最大值
         3)遍历其他元素,依次这个参照物进行比较,如果后面元素比它大,后面的元素就最大值
         4)输出结果即可!
         
         最小值:同理
 
class ArrayTest2{
	public static void main(String[] args){
		
		//创建一个数组,静态初始化
		int[] arr = {69,1,58,13,6,98,76,9} ;
		
	
		int max = getMax(arr) ;
		System.out.println("数组中最大值是:"+max) ;
		
		System.out.println("----------------------------------------") ;
		
		int min = getMin(arr) ;
		System.out.println("数组中最小值是:"+min) ;
	}
	
	public static int getMin(int[] arr){
		//定义一个参照物
		int min = arr[0] ;
		//遍历其他元素
		for(int x = 1; x < arr.length; x++){
			//如果后面的元素比min小,就是最小值
			if(arr[x] < min){
				min = arr[x] ;
			}
		}
		return min ;
	}
	
	public static int getMax(int[] arr){
		//定义参照物
		int max = arr[0] ;
		
		//遍历其他元素
		for(int x = 1 ; x < arr.length ; x ++){
			//判断:使用后面的元素依次和当前参照物比较
			if(arr[x] > max){
				max = arr[x] ; 
			}
		}
		return max ;
	}
	
}
 
   2.4.3 逆序 
        数组元素逆序
             分析:
                 将arr[0]元素和arr[arr.length-1]互换
                 将arr[1]元素和arr[arr.length-2]互换
                 ...
                 ...
 
class ArrayTest3{
	
	public static void printArray(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]+", ") ;
			}
		}
	}
}
 
  2.4.4 数组元素查询 
    数组的元素查表法:最简单的查询
             数组名称[索引值]访问元素
 
import java.util.Scanner ;
class ArrayTest4{
	
	public static void main(String[] args){
		//创建一个字符串数组对象,静态初始化
		String[] strArray = {"星期一","星期二","星期三","星期四","星期五",
			"星期六","星期日"};
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//提示并录入数据
		System.out.println("请您输入一个数据(0-6):") ;
		int num = sc.nextInt() ;
		
		System.out.println("您要查找的是:"+strArray[num]) ; //角标从0开始
	}
}
 
  2.5 冒泡排序 
        两两比较,将较大的值往后放,第一次比较完毕,最大值就出现在最大索引处
     依次这样比较,即可得到排好序的数组...
 
class ArrayDemo{
    public static void main(String[] args){

        //创建一个数组,静态初始化
        int[] arr = {24,69,87,56,13} ;

        System.out.println("排序前:") ;

        //调用遍历功能
        printArray(arr) ;

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


        bubbleSort(arr) ;
        //输出遍历结果
        printArray(arr) ;
    }
    public static void bubbleSort(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 printArray(int[] arr){
        //[
        System.out.print("[") ;
        for(int x = 0 ; x < arr.length ; x ++){
            //判断是否是最大索引值
            if(x == arr.length-1){
                System.out.println(arr[x]+"]") ;
            }else{
                //中间元素
                System.out.print(arr[x]+", ") ;
            }
        }
    }
}
 
3.类 
        定义:描述一组事物的属性和行为的集合.是java中最基本的单元.
         包含:成员变量 在类中,方法外.
             成员方法 格式  public 返回类型 方法名(形式参数列表){
                   业务体
             }
 
4.面向对象 
        思想特点:
                    1)更符合我们生活中思想行为习惯
                    2)让更复杂的事情简单化
                    3)角色发生了变化:我们从执行者变成了指挥者!
 
                设计原则:
                         不断的创建对象,使用对象,指挥对象.
                 特征:封装,继承,多态.
 
  4.1 对象 
        定义;描述一个具体的事物.  在测试类中使用:main方法所在类
         代码体现:
            格式: 类名 对象名=new 类名();
            给具体的事物属性赋值
            对象名.成员变量=赋值;
            调用具体事物的行为
            对象名.成员方法名();
 
class Phone{
	String brand ;
	int price;
	String color;
	String neiCun;
	

	public void phoneCall (){
	System.out.println("手机可以打电话");
}

	public void playGames (){
	System.out.println("打游戏");
}

	public void sendMessage (){
	System.out.println("还可以发短信");
}

}

public class PhoneTest{
	public static void main (String[] args){
	Phone p = new Phone();
	
	p.brand = "iPhone" ;
	p.price = 8888;
	p.color = "black" ;
	p.neiCun = "512GB" ;
	
	System.out.println("这个手机的品牌是"+p.brand+",价格是"+p.price+",颜色是"+p.color+",内存是"+p.neiCun+".");
	
	p.phoneCall();
	p.playGames();
	p.sendMessage();
	}
}
 
4.2 局部变量和成员变量的区别: 
  1)在类中的书写位置不同:
        局部变量:在方法中定义或在方法声明上;
        成员变量:在类中,方法外;
   2)在内存中的位置不同:
        局部变量:在栈内存中
        成员变量:在堆内存中
   3)生命周期不同:
        局部变量:随着方法的调用而存在,随着方法的调用结束而消失;
        成员变量:随着对象的创建而存在,随着对象的调用结束完毕,等待垃圾回收器空闲回收不会立即消失.
   4)初始化时机不同:
        局部变量:要么先定义,使用之前必须初始化,要么直接初始化.
        成员变量:可以不赋值,系统默认堆成员变量初始化;也可以通过对象名.成员变量=赋值;
 
4.3 匿名对象 
匿名对象:没有名字的对象
         
         创建对象的格式:
         类名 对象名 = new 类名() ;
         Student s = new Student() ;
          匿名对象的格式:
                 new 类名() ;
                 好处:
                     1)节省内存空间
                     2)开发中,匿名对象一般 使用"一次即可",使用完毕就立即垃圾回收器回收!
                     3)手机移动端/Android/鸿蒙系统:基于Java语言
                         ios系统:基于c语言
                 访问类的成员变量:
                 new 类名().成员变量名;
                 访问类的成员方法:没有具体返回值类型
                 new 类名().成员方法名() ;
 
class Student{
	public void study(){
		System.out.println("好好学习,天天向上...") ;
	}
	
	
}
//定义一个类:StudentDemo
class StudentDemo{
	
	//show方法里面形式参数是引用类型:具体的类Student
	public void show(Student s){
		s.study() ;//new Student().study();
	}
}
//测试类
public class NoNameDemo{
	public static void main(String[] args){
		//需求:访问StudentDemo类中的show方法
		//1)创建当前StudentDemo类对象
		StudentDemo sd = new StudentDemo() ;
		//调用show()
		Student s  = new Student() ;
		sd.show(s) ; //实际参数需要创建Student类的对象
		
		System.out.println("-----------------------------------------") ;
		//匿名对象的格式:
		//new 类名() ;
		
		//需求:访问StudentDemo类中的show方法
		StudentDemo sd2 = new StudentDemo() ;
		sd2.show(new Student()) ;
		
		
		System.out.println("-----------------------------------------") ;
		
		//一步走:链式编程
		new StudentDemo().show(new Student()) ;
	}
}
 
5.封装 
    private:私有的,不能直接访问的;
     特点:
         被private修饰的成员变量或者是成员方法,只能在本类中访问;外界类是不能直接访问的,间接可以通过公共的成员方法访问.
 
        为了保证类的属性的安全性,所有的属性都必须加入private关键字,并且对外提供公共的访问方法间接的对成员变量(属性)进行赋值.
 
         setXXX()/getXXX():都是public的:权限足够大.
          总结:属性私有化,对外提供给公共的成员方法访问方法:setXXX()/getXXX()
 
class Student{
    String name ; //姓名
    private int age ; //年龄

    //给年龄赋值:setAge
    public void setAge(int a){//24
        age = a ; //age = 24 ;
    }

    //获取年龄值
    public int getAge(){
        return age ;
    }

    //吃
    public void eat(){
        System.out.println("饿了需要吃饭...") ;
    }
    //学习
    public void study(){
        System.out.println("玩够了,就需要充电...") ;
    }
}
//学生类的测试类
class StudentTest{
    public static void main(String[] args) {
        //创建一个学生类对象
        Student s = new Student();
        s.name = "李华";
        //s.age
        //访问功能方法
        s.setAge(24);
        s.eat();
        s.study();
    }
}