第三周总结

方法

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

有具体返回值类型的方法定义

Java中方法的定义格式:   
    有具体返回值类型的方法定义   
        固定格式:
        权限修饰符 static  返回值类型 方法名(形式参数类型1 变量名1,形式参数类型2 变量2....){          
            //功能业务操作
            return 结果;
        }       
    public static 返回值类型 方法名(形式参数类型1 变量名1,形式参数类型2 变量2....){
            //功能业务操作
            return 结果;
        }       
    解释:
        权限修饰符:现在方法访问权限:公共的/公开的,访问权限足够大,public
        static:面向对象在讲,目前来说必须带上static
        返回值类型:数据类型 (目前使用的基本类型)
        方法名:见名知意,满足标识符的规则...(小驼峰命名法)
        形式参数类型:数据类型(目前使用的基本类型)
        变量名:定义参数名称 (见名知意)满足标识符的规则...(小驼峰命名法)
    有具体返回值类型的方法调用
        方法名(实际参数) ;
        1)单独调用:没有输出
        2)输出调用:可以用,不建议用,因为如果需要将结果进一步操作,写死,不太好!
        3)赋值调用:推荐       
    有返回值类型方法调用:赋值调用 
        返回值类型 变量名  = 方法名(实际参数名1,实际参数名2....);
    使用变量名即可!

Java中定义方法和调用方法的注意事项(有返回值类型的方法)
    1)方法和方法是平级关系,在一个方法中不能嵌套定义另一个方法
    2)Java是一个强类型语言,定义方法的时候,形式参数类型必须携带,不能省略!
           function add(a,b){}
    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)赋值调用:不行

方法重载

多个方法名相同,参数列表不同,与返回值无关       
    参数列表不同:
        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){} :不是重载                                            
方法重载的目的:就是为了让这个功能扩展性更多;方法中接收常用的一些数据类型参数

数组

数组是只能够存储同一种类型的容器,在同一数组中,元素的数据类型必须一致
数组定义格式:
    数据类型[] 数组名称;
    数据类型 数组名称[] ;       
    数据类型:学习基本数据类型       
举例:             
    int[] arr ;  定义了一个int类型的数组变量arr
    int arr[] ;  定义了一个int类型的arr数组变量     
数组的初始化:
    1)动态初始化:我们给定数组的长度,元素由系统(Jvm)默认初始化
        数据类型[] 数组名称 = new 数据类型[长度] ; 推荐第一种
        数据类型 数组名称[] = new 数据类型[长度] ;    
            创建一个数组对象
            int[] arr = new int[3] ;
            int arr[] = new int[3] ;
    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} ;         
    注意事项:
        数组的初始化:要么动态初始化/要么静态初始化,不能"动静结合"         
        int[] arr = new int[3]{1,2,3} ;  错误的!
        
数组属于引用类型

冒泡排序

数组高级排序算法之冒泡:
    思想:
        两两比较,将较大的值往后放,第一次比较完毕,最大值就出现在最大索引处
    依次这样比较,即可得到排好序的数组...

class Maopao{
    public static void main(String[] args){
        int[] arr = {23, 32, 216, 621, 126, 1};
        System.out.println("比较排序前是:");
        qian(arr);
        System.out.println("-----------------------------------------------");
        System.out.println("比较排序后是:");
        bubbleSort(arr);
        qian(arr);
    }
    public static void bubbleSort(int[] arr){
        for(int a = 0 ; a < arr.length - 1 ; a++){
            for(int x = 0; x < arr.length - 1 - a; x++){
                if(arr[x] > arr[x+1]){
                    int b = arr[x];
                    arr[x] = arr[x+1];
                    arr[x+1] = b;
                }
            }
        }
    }
    public static void qian(int[] arr){
        System.out.print("[");
        for(int a = 0; a < arr.length; a++){
            if(arr[a] == arr[arr.length-1]){
                System.out.println(arr[a]+"]");
                break;
            }
            System.out.print(arr[a]+", ");
        }
        
    }
}

面向对象

本质是基于面向过程完成的;

面向过程的代表语言:C语言
  完成某一件事情,从分析,到实现,都是自己亲力亲为完成的!
  举例:
  	需求:获取数组中的最大值
  	分析:
  		1)有一个数组
  		2)定义参照物
  		3)遍历其他数组
  		3.1)获取到每一个元素,依次和参照物进行比较
  		如果后面的元素比参照物大
  		后面元素就是最大值
  		4)输出结果;
面向对象的代表语言:Java,c++,python...

思想特点

面向对象的思想特点:
       	1)更符合我们生活中思想行为习惯 
       	2)让更复杂的事情简单化
		3)角色发生了变化:我们从执行者变成了指挥者! 
	举例
	 做饭:
       	面向过程;
       		 去菜市场---->看一看--->讨价还价--->摘菜----->洗菜---->切菜--->加油---->炒菜---放调料---->出锅
       	面向对象:
       		 找一个对象---->等待出锅

设计原则

在程序中(符合生活中的场景),不断的创建对象,使用对象,指挥对象做事情(完成功能...)
举例:
	1)创建键盘录入对象:Scanner
	2)录入int类型/String类型数据

三大特征

封装, 继承, 多态

类

概念:能够描述一组事物的属性和行为的集合---->类
类------>能够描述现实世界真实存在的 "事物"
举例:
	学生事物:
		属性:性别,年龄,姓名,学号,身高,班级,体重...
                        能够描述一个学生具体特点
		行为:	 主要的行为:学习, 吃,睡,玩..
                        能够描述学生干什么
使用Java代码的方式 描述现实世界存在的事物	
	Java中最基本的单元:类-----> 事物
		成员变量------->描述事物的属性
		成员方法(非静态的)------->描述事物的行为	
		成员变量: 在类中,方法外;
		成员方法: 之前怎么定义方法,现在还怎么写,不过,去掉static关键字
		public 返回这里类型 方法名(形式参数列表){
			业务体
			有具体结果1)return 结果  ;
			没有具体结果:输出 打印...
		}
		
定义:
	两个明确
	1)明确返回值 :有-->给具体类型 ,没有:void 代替 输出结果
	2)明确参数类型,以及参数个数
	具体情况,具体分析

类与对象的关系

类----描述真实事物
对象----体现出 "具体的事物"
代码体现:
	格式:
      类名 对象名  = new  类名() ;     		
   给具体事物属性赋值
        对象名.成员变量 = 根据类型赋值;
   调用具体事物的行为
        对象名.成员方法名() ;

访问成员变量和成员方法

        类名 对象名  = new 类名() ;
	访问成员变量:
	对象名.成员变量名  =  根据类型赋值;
	对象名.成员方法名() ; //这个方法没有具体返回值类型	
	返回值类型 变量名 = 对象名.成员方法名() ;//有具体返回值类型的方法
	输出变量名; 

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

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

匿名对象

匿名对象:
	顾名知意:没有名字的对象				
创建对象的格式:
	类名 对象名 = new 类名() ;
	Student s = new Student() ;				
匿名对象的格式:
	new 类名() ;
好处:
	1)节省内存空间
	2)开发中,匿名对象一般 使用"一次即可",使用完毕就立即垃圾回收器回收!
	3)手机移动端/Android/鸿蒙系统:基于Java语言
		ios系统:基于c语言		
访问类的成员变量:
	new 类名().成员变量名;
访问类的成员方法:没有具体返回值类型
	new 类名().成员方法名() ;
实例:
	StudentDemo sd2 = new StudentDemo() ;
	sd2.show(new Student()) ;

封装

private:私有的,不能直接访问的;
特点:
	被private修饰的成员变量或者是成员方法,只能在本类中访问;
	外界类是不能直接访问的,间接可以通过公共的成员方法访问!
		
权限修饰符:
		private :最小
		public: 最大
实例:
class Demo{
	//公共的成员变量
	public int num = 100 ;
	private int num2 = 200 ;
    
	//定义一个公共方法
	public void show(){
		System.out.println(num) ;
		System.out.println(num2) ;
	}
	//定义一个公共的成员方法
	public void method(){
		System.out.println("hello,method...") ;
		System.out.println("------------------") ;
		function();		
	}
	//定义一个私有的成员方法
	private void function(){
		System.out.println("hello,function...") ;
	}
}

this关键字

this:代表当前类对象的地址值引用

定义一个学生类:Student
	成员变量:私有化----加入private
			name,age,gender,id,hobit		
	成员方法:
			setXXX()/getXXX():给学生信息赋值/获取值
			study(),playFootball(),watchMove()
	局部变量名称和成员变量名称一致(局部变量隐藏了成员变量),Java提供了一个关键字:this
实例:
	public void setName(String name){ //name赋值的姓名  
		//访问成员变量 = 局部变量;
		this.name = name ; 	
		//上面代码存在问题:局部变量名称和成员变量名称一致
		//加入this之后,格式变成this.xx=xx;
	}	
	//获取学生的姓名
	public String getName(){
		return name ;
	//getXXX()方法里面隐藏this
	//return this.name ; //省略this :就是上面的写法
	}

构造方法

一个类的成员:
	成员变量--->私有化(封装)
	成员方法			
新的成员:构造方法			
什么是构造方法:
	构造方法是一种特殊的方法,方法名和类名一致;	
特点:
	1)方法名和类名一致;
	2)构造方法没有返回值类型
	3)连void都没有			
构造方法是重载的!		
方法重载:
	方法名相同,参数列表不同,与返回值无关!
		参数列表不同:
			参数个数
				参数类型
					考虑类型先后属性				
分类:
	无参构造方法:没有参数
	有参构造方法:有具体的参数类型			
构造方法的作用:就是对类中的数据(成员属性)进行初始化
实例:
//定义了一个学生类
class Student{		
	//显示给出了 无参构造方法
	public  Student(){
		System.out.println("这是Student类的无参构造方法...") ;
	}
	//有参构造方法
	public Student(String name){	
		System.out.println("这是Student类的带String类型的有参构造方法...") ;
	}
	//带两个参数的构造方法
	public Student(String name,int age){
		System.out.println("这是带两个参数的有参构造方法....") ;
	}		
}
//测试类
class ConstructorDemo{
	public static void main(String[] args){	
		//创建学生类对象
		Student s = new Student() ;
		System.out.println(s) ;//Student@6d06d69c
		/*
		这是Student类的无参构造方法...
		Student@6d06d69c
		*/
		System.out.println("------------------") ;
		//创建学生对象
		Student s2 = new Student("张三") ;
		System.out.println(s2) ;	
		System.out.println("------------------") ;
		//在创建学生对象
		Student s3 = new Student("张三",42) ;
		System.out.println(s3) ;
		/*
		这是带两个参数的有参构造方法....
		Student@4e25154f
		*/
	}
}

构造方法注意事项

构造方法的注意事项:
	1)当我们开发者既没有提供无参构造方法,也没有提供有参构造方法,系统永远给我们提供 "无参构造方法"
	类名 对象名 = new 类名() ; //创建对象的格式
	2)如果我们提供了有参构造方法,那么系统不会在提供无参构造方法
构造方法的作用:给类的成员属性可以进行数据初始化	
给成员变量(私有修饰)赋值几种方式:
	1)公共的访问方法setXXX(xx):赋值
	2)有参构造方法进行赋值
		public 类名(参数类型1 变量名1,参数类名2 变量名2...){			
			this.成员变量名1 = 变量1;
			this.成员变量名2 = 变量2 ;
			...
		}

一个标准类的写法

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(42) ;
		s.setGender("男") ;
		System.out.println("该学生的姓名是"+s.getName()+
		",年龄是:"+s.getAge()+",性别为:"+s.getGender()) ;
		
		s.study() ;
		s.playGame("王者农药") ;
		
		System.out.println("---------------------------------------") ;
		
		//方式2:测试
		//有参构造方法+getXXX()
		Student s2 = new Student("翠花",45,"女") ;
		System.out.println("该学生的姓名是"+s2.getName()+
		",年龄是:"+s2.getAge()+",性别为:"+s2.getGender()) ;
		
		s2.study() ;
		s2.playGame("吃鸡") ;
	}
}