Java学习第三周

2021/10/7 17:11:59

本文主要是介绍Java学习第三周,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

方法:

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

Java中方法的定义格式分两种情况

         1)有具体返回值类型的方法定义
         2)没有具体返回值类型的方法定义

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

                public static 返回值类型 方法名(形式参数类型1 变量名1,形式参数类型2 变量2....){
            //功能业务操作
            return 结果;
        }

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

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

eg:

​
class FunctionDemo{
	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);
 		
	}
	
	/*
		求两个数据之和,使用方法来完成! 默认都是int
				
		public static 返回值类型 方法名(形式参数类型1 变量名1,形式参数类型2 变量2....){
			//功能业务操作
			return 结果;
		}
		
        心中:两个明确
		1)明确返回值类型  int
		2)明确参数类型以及参数个数
				int 2个
	*/
	public static int add(int a,int b){
		//功能业务操作
		int c = a+ b;
		return c ;

	}
}

​

Java中定义方法和调用方法的注意事项(有返回值类型的方法)
        1)方法和方法是平级关系,在一个方法中不能嵌套定义另一个方法
        2)Java是一个强类型语言,定义方法的时候,形式参数类型必须携带,不能省略!
                                        后期学习前端javascript:弱类型语言    
                                        function add(a,b){}
        3)调用方法的时候,实际参数不需要携带数据类型的                

        4)定义方法的时候,后面千万不能来一个分号,这个方法缺少方法主体的,没有意义!
                有{左大括号的地方不能有分号;
                有;号的地方不能有{左大括号
        public static int add(int a,int b);
        {   没有意义
            return a + b ;
        }

2)没有具体返回值类型的方法格式:

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

        没有具体返回值类型方法定义格式:固定写法
         public static void 方法名(参数类型1 变量名1,参数类型2 变量名2....){
         输出语句/或者数据交换...            
        }

没有具体返回值类型方法调用:
        1)单独调用:推荐!
            方法名(实际参数列表) ;
        2)输出调用:不行
        3)赋值调用:不行

 

class FunctionDemo3{
	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("-------------------------------------------") ;
		
		
		//将上面封装到代码块中
		//调用方法来完成
		
		
		//: 非法的表达式开始 :不能用void result = printXing(5,6) ;
		//System.out.println(result) ;
		
		
		//输出调用:不能用 非法表达式
		//System.out.println(printXing(5,6)) ;
		
		//单独调用即可:推荐
		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 <m  ; x ++){//控制行数
			for(int y = 0 ; y< n ; y ++){//控制列数
				System.out.print("*") ;
			}
			System.out.println() ;
		}
	}	
}

方法重载(OverLoad)

标识符的规则:见名知意    ---现在的功能都是"求和",那么Java中多个方法的功能如果一样的,
那么这些方法名字可以同名-----> 方法重载(OverLoad)

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

面向对象中:继承中: 方法重写(Override)

​
class FunctionDemo4{
	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)) ;
	}
	/*
	求两个数据之和的方法
		两个明确
		1)明确返回值类型:int
		2)明确参数类型以及参数个数:
			int,2个	
	*/
	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 ;
	}
	
}

​

 数组:

 是只能够存储同一种类型的容器,在同一数组中,元素的数据类型必须一致!

数组定义格式:
        数据类型[ ] 数组名称;          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} ;  错误的!

数组就是引用类型,引用类型下面经常会出现异常:

运行时期异常:
                ArrayIndexOutOfBoundsException:数组角标越界异常
                NullPointerException:空指针异常

    程序在过程中,经常会出现"异常";   后期常用类中讲
    程序有问题            
        1)编译时期异常:jvm检查语法不通过; 语法格式存在问题
                    举例:
                            同一个变量被定义多次
                            数组格式写错
                            ...                            
         2)运行时期异常:开发者:代码书写不严谨导致的问题        
                        键盘录入:  代码书写---->录入int类型
                                    int num = 键盘录入对象.nextInt() ;
                                    
 java.lang.ArrayIndexOutOfBoundsException:数组角标越界异常
        出现的原因:访问了数组中不存在的角标(索引值)
        如何解决:检查代码,更改索引值                       
 java.lang.NullPointerException:空指针异常
        引用类型的默认值都是null;
        String s = null ;  字符串是一种特殊的引用类型
        出现的原因:某一个对象已经为空了,null(没有堆内存地址),这个时候还要去访问元素或者调用
        这个对象的方法,那么就出现空指针;
        如何解决:
            使用逻辑判断语句,对该对象进行非空判断

面向对象:     

完成某一件事情,从分析,到实现,都是自己亲力亲为完成的!

面向对象的代表语言:Java,c++,python...
面向对象跟面向过程:生活中处处皆对象

举例:
         洗衣服这件事情
         面向过程: 
             1)脱下脏衣服--->2)找一个盆子-----3)放入洗衣液-----4)泡一泡-----5)搓一搓-----6)透水
             ----7)拧一拧----->8)抖一抖-----9)晾一晾
         面向对象:
             1)脱下脏衣服---->2)全自动洗衣机(一键)----->3)晾一晾

面向对象的思想特点:
           1)更符合我们生活中思想行为习惯 
           2)让更复杂的事情简单化
           3)角色发生了变化:我们从执行者变成了指挥者!  

Java语言:面向对象语言---->它的设计原则

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

Java语言面向对象的三大特征:  封装,继承,多态!

1.类:能够描述一组事物的属性和行为的集合 

类------>能够描述现实世界真实存在的 "事物" 

学生事物
        属性:性别,年龄,姓名,学号,身高,班级,体重...                   能够描述一个学生具体特点
        行为:     主要的行为:学习, 吃,睡,玩..                               能够描述学生干什么

现在使用Java代码的方式 描述现实世界存在的事物    
Java中最基本的单元:类        -----> 事物
        成员变量------->       描述事物的属性
        成员方法(非静态的)------->       描述事物的行为
        
        成员变量: 在类中,方法外;
        成员方法: 之前怎么定义方法,现在还怎么写,不过,去掉static关键字
                         public 返回这里类型 方法名(形式参数列表){
                            业务体
                            //有具体结果1)return 结果  ;                            
                            //没有具体结果:输出 打印...
                    }
        
                    定义:
                            两个明确
                            1)明确返回值 :有-->给具体类型 ,没有:void 代替 输出结果
                            2)明确参数类型,以及参数个数
                                    具体情况,具体分析

2.类与对象的关系

 类----描述真实事物的                                        
 学生事物                
        属性:
                姓名
                年龄
                住址
                ..
            行为:
                学习JavaSE                        
 学生类
            class Student{
                //成员变量 ---事物属性
                String name ;//姓名
                int age ;//年龄
                String address;//住址
                //...                
                //成员方法----事物的行为
                public void study(String name){
                    System.out.println("正在学习"+name)
;
                }
            }        
什么是对象?
         体现出 "具体的事物"       因为类---描述事物----概括的事物("总称")  
在测试类中使用:main方法所在类            
代码体现:
            格式:
                类名 对象名  = new  类名() ;                
                给具体事物属性赋值
                对象名.成员变量 = 根据类型赋值;
                调用具体事物的行为
                对象名.成员方法名() ;


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

class Variable{
	//成员变量
	int num ;
	
	//成员方法
	public void  show(int a){//局部变量
		int b ; //可能尚未初始化变量b
		//要么先定义,使用之前,初始化;要么直接初始化
		System.out.println(a) ;
		b = 20 ;
		System.out.println(b) ;
	}
}

//测试类
class VariableDemo{
	public static void main(String[] args){
		//访问num变量如何访问?
		//创建当前类Variable对象
		//类名 对象名= new 类名() ;
		Variable v = new Variable() ;
		System.out.println(v.num) ;
		v.num = 10 ;
		System.out.println(v.num) ;
		System.out.println("-------------------") ;
		v.show(100) ;
	}
}

匿名对象: 顾名知意:没有名字的对象

 创建对象的格式:
        类名 对象名 = new 类名() ;
        Student s = new Student() ;

匿名对象的格式:
        new 类名() ;

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

封装

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...") ;
	}
}
//测试类
class PrivateDemo{
	public static void main(String[] args){
		//需求:访问Demo类的num
		//创建Demo类对象
		Demo d = new Demo() ;
		System.out.println(d.num) ;
		System.out.println("--------------------------") ;
		//System.out.println(d.num2) ;//错误: num2 在 Demo 中是 private 访问控制
		//通过公共方法间接访问私有的成员变量		
		d.show() ;		
		System.out.println("--------------------------") ;		
		//对象名.成员方法名();
		d.method() ; //间接访问公共访问---访问的私有方法;
		//d.function();// function() 在 Demo 中是 private 访问控制
	}
}

this关键字: 

                
    定义一个学生类:Student
        成员变量:私有化----加入private
                name,age,gender,id,hobit                               
        成员方法:
                setXXX()/getXXX():给学生信息赋值/获取值                
                study(),playFootball(),watchMove()           
                    
    代码存在弊端:
            讲标识符:在实际开发中,起名字(变量/方法/类)见名知意
            当前代码中的setXXX(形式参数):都是 n,a,g,i,h:不太合适
            既然见名知意:
                    name,赋值一个姓名
                    age:赋值年龄
                    gender:赋值性别
                    id:赋值学号
                    hobit:赋值爱好           
        
            局部变量名称和成员变量名称一致(局部变量隐藏了成员变量),Java提供了一个关键字:this

            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 Teacher{
	//提供两个属性 :属性私有化
	private String name ;//姓名
	private int age ; //年龄		
	//没有提供任何构造方法
	
	//提供无参构造方法
	public Teacher(){		
	}	
	//只是提供有参构造方法
	public Teacher(String name,int age){//"高圆圆",42				
		//局部变量隐藏成员变量:通过this区分
		this.name = name ;
		this.age = age ;
	}	
	//提供setXXX()/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 ;
	}	
	//老师学习/讲课的方法...
}
//测试类
class ConsturctorDemo2{
	public static void main(String[] args){
		//创建Teacher类对象
		Teacher t = new Teacher() ;
		//通过setXXX(xx);赋值
		t.setName("苍井空") ;
		t.setAge(18) ;
		System.out.println(t.getName()+"---"+t.getAge()) ;		
		System.out.println("-------------------------------") ;				
		//通过有参构造方法也可以赋值
		Teacher t2 = new Teacher("高圆圆",42) ;
		System.out.println(t2.getName()+"---"+t2.getAge()) ;
	}
}

一个标准类的写法:

 使用学生类描述学生事物,并且进行测试    
        学生事物的属性
                姓名,年龄,性别
        学生事物的行为:
                学习,玩游戏        
 定义学生类
            成员变量:私有化
                        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(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("吃鸡") ;
	}
}



这篇关于Java学习第三周的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程