Java教程
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("吃鸡") ;
}
}
-
Springboot应用的多环境打包入门11-23
-
Springboot应用的生产发布入门教程11-23
-
Python编程入门指南11-23
-
Java创业入门：从零开始的编程之旅11-23
-
Java创业入门：新手必读的Java编程与创业指南11-23
-
Java对接阿里云智能语音服务入门详解11-23
-
Java对接阿里云智能语音服务入门教程11-23
-
JAVA对接阿里云智能语音服务入门教程11-23
-
Java副业入门：初学者的简单教程11-23
-
JAVA副业入门：初学者的实战指南11-23
-
JAVA项目部署入门：新手必读指南11-23
-
Java项目部署入门：新手必看指南11-23
-
Java项目部署入门：新手必读指南11-23
-
Java项目开发入门：新手必读指南11-23
-
JAVA项目开发入门：从零开始的实用教程11-23
