跳转控制语句---return
1)return:返回具体的值(结束方法)
很少单独使用,需要在具有返回值类型中使用
return 结果值:
方法的概念
给一个功能代码块,使用{}包裹起来并且为之起一个名字,每次语句同样的功能,只需要通过名字(方法名)调用即可!
两种定义格式:
1)有返回值类型的方法的定义
2)没有具体返回值类型的方法定义
有具体返回值的方法定义以及调用
定义格式
public static 具体的返回值类型 方法名(参数类型1 变量名1,参数类型2 变量名2...){
完成功能业务;
return 具体返回结果;
权限修饰符:现在方法访问权限:公共的/公开的,访问权限足够大,public
static:面向对象在讲,目前来说必须带上static
返回值类型:数据类型
方法名:见名知意,满足标识符的规则...(小驼峰命名法)
形式参数类型:数据类型
变量名:定义参数名称 (见名知意)满足标识符的规则...(小驼峰命名法)
有具体返回值类型的方法调用
方法名(实际参数) ;
1)单独调用:没有输出
2)输出调用:
3)赋值调用:(推荐使用)
举例:
import java.util.Scanner ;
class Dome{
public static void main(String[] args){
//键盘录入两个数据,比较两个数据是否相等
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入第一个数据:") ;
int a = sc.nextInt() ;
System.out.println("请您输入第二个数据:") ;
int b = sc.nextInt() ;
//赋值调用
boolean flag = compare(a,b) ;
System.out.println("flag:"+flag) ;
}
public static boolean compare(int a,int b){
return a == b ;
}
}
定义方法的注意事项
1)方法和方法不能嵌套,他们是平级关系,只能相互调用 ;
2)方法定义的时候,形式参数类型必须带上,否则就是未知类型,Java是一个强类型语言,语法非常严谨!
3)调用方法的时候,实际参数无须携带数据类型,
方法名(实际参数名称1,实际参数名称2) ;
4)定义方法的时候,有{左大括号的地方不能有分号;有;分号地方不能有{左大括号
没有具体返回值的定义以及调用
public static void 方法名(参数类型1 变量名1,参数类型2 变量名2....){
输出语句/业务直接输出;
}
没有具体返回值类型方法调用:
1)单独调用:方法名(实际参数列表) ;(推荐使用)
2)输出调用
3)赋值调用
举例:
//键盘录入数据n,打印nn乘法表
import java.util.Scanner ;
class Test2{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入
System.out.println("请您输入一个数据n(1-9):") ;
int n = sc.nextInt() ;
//调用方法
printNN(n) ;
}
public static void printNN(int n){//形参
for(int x = 1 ; x <= n ; x ++){//行数
//列数变化:取值<=x
for(int y = 1 ;y <=x ; y ++){
System.out.print(x+"*"+y+"="+(y*x)+"t") ;
}
System.out.println() ;
}
}
}
方法的重载
重载目的:提供该功能的扩展性
方法重载:定义多个方法,方法名相同,参数列表不同,与返回值无关!
参数列表不同:1)参数类型不同2)参数个数不同3)参数顺序不同
数组
数组是什么样的容器:
是只能够存储同一类型的容器,在同一数组中,元素类型必须一致
格式:
数据类型 [] 数组名称;
数据类型 数组名称 [];
动态初始化和静态初始化
动态初始化:我们给定数组的长度,元素由系统(Jvm)默认初始化
数据类型[] 数组名称 = new 数据类型[长度] ; 推荐第一种
数据类型 数组名称[] = new 数据类型[长度] ;
整数默认int:--------int类型 默认值为0
浮点默认double:-------double类型 默认值为0.0
静态初始化:给定数组的具体元素,系统默认分配长度
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3...} ;
简化格式:
数据类型[] 数组名称 = {元素1,元素2,元素3...} ;
注意:
初始化不能同时给定,不能这样写,不能动静集合!
数据类型[] 数组名称 =new 数据类型[长度]{元素1,元素2,元素3...} ;
数组:引用类型Java内存分配
栈内存:
存储局部变量:
局部变量:在方法定义中或者方法声明上的变量;
生命周期:随着方法调用而存在,随着方法调用结束而消失! :基本数据类型
public static int add(int a,int b){
return a+b;
}
方法需要加载进栈---->压栈
出栈的方式---->弹栈
栈结构特点:先进后出
堆内存: new 出来的东西都在这里面存储
举例:
Scanner sc = new Scanner(System.in) ;
一个数组,动态初始化
int[] arr = new int[3] ;
方法区:
字节码文件区域/static静态区域/常量池
本地方法区/寄存器:本地系统和cpu有关系
异常
数组就是引用类型,引用类型下面经常会出现异常:
运行时期异常:
ArrayIndexOutOfBoundsException:数组角标越界异常
NullPointerException:空指针异常
StringIndexOutOfBoundsException:字符串角标越界异常
java.lang.ArrayIndexOutOfBoundsException:数组角标越界异常
出现的原因:访问了数组中不存在的角标(索引值)
解决方案:检查代码,更改索引值
java.lang.NullPointerException:空指针异常
引用类型的默认值都是null;
String s = null ; 字符串是一种特殊的引用类型
出现的原因:某一个对象已经为空了,null(没有堆内存地址),这个时候还要去访问元素或者调用
这个对象的方法,那么就出现空指针;
解决方案:
使用逻辑判断语句,对该对象进行非空判断
数组的基本应用
//数组最大的弊端:数组长度固定的,不支持长度可变的需求!------------>
//1)遍历
//[元素1, 元素2, 元素3, ....]
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)数组逆序
//将arr[0]--- arr[arr.length-1]互换
//arr[1] ----arr[arr.length-1-1]互换
//...
public static void reverse(int[] arr){
//起始索引start
//最终索引end
for(int start = 0 ,end = arr.length-1; start < end; start++,end--){
//定义中间变量互换
int temp = arr[start] ;
arr[start] = arr[end] ;
arr[end] = temp ;
}
}
//逆序完毕,之后还需要变量数组----"输出出来"
//3)数组最值问题:最大值/最小值
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 ;
}
//4)数组的基本元素查找 (查询数组中的元素第一次出现索引值)
public static int getIndex(int[] arr,int key){
//假设思想:
//定义一个变量index
int index = -1 ; //找不到
//遍历数组
for(int x = 0 ; x < arr.length ; x ++){
//判断:如果当前key 和 arr[x] 一致,找到了
if(key == arr[x]){
//更改index的值
index = x ;
break ; //结束循环了
}
}
return index ;
}
数组的高级应用:排序算法
数组高级排序算法之冒泡:
两两计较,较大的值往后放第一次完毕比较最大的值就出现在最大索引处
比较次数 数组名.length-1
核心代码:
for(int x = 0 ; x arr[y+1]) {
int temp = arr[y] ;
arr[y] = arr[y+1] ;
arr[y+1] = temp ;
}
}
}
面向对象基本思想
1)更符合生活中思想行为习惯
2)将复杂的事情简单化
3)角色发生变化,从执行者变成了指挥者(指挥对象做事情)
举例:
做饭:
面向对象思想: 本质基于面向过程
找一个对象---->等待出锅完成...
面向对象的三大特征
封装,继承,多态
类和对象的关系
类:描述一组真实事物的属性和行为的集合
类------描述现实世界真实存在"事物":一一对应关系
事物中的属性 类中的成员方法
事物中的行为 类中的成员变量
Java中最基本的单元:类
举例:
学生事物 学生类:Student
手机事物 手机类:Iphone
工人事物 工人类:Worker
对象:描述 具体的"事物",通过代码操作:创建当前类的对象
类(事物):只是一个泛指 对象:当前事物的具体体现
创建具体对象的格式和访问成员变量和方法
类名 对象名 = new 类名();
访问成员变量:
对象名.成员变量名 = 根据类型赋值;
对象名.成员方法名() ; //这个方法没有具体返回值类型
返回值类型 变量名 = 对象名.成员方法名() ;//有具体返回值类型的方法
输出变量名;
成员变量和成员方法如何书写
class Iphone{
String brand;
int price;
String color;
int memory;
public String playGame(String gameName){
return "关羽正在玩"+gameName;
}
public String call(String name){
return "孙尚香"+name+"打电话";
}
public void weiXin(){
System.out.println("赵云正在发短信");
}
public String study(String object){
return "马超正用手机学习"+object;
}
}
class IphoneTest{
public static void main(String[] args){
Iphone phone = new Iphone();
phone.brand ="小米";
phone.price = 3000;
phone.color ="天空蓝";
phone.memory =256;
System.out.println("这个手机的品牌为:"+phone.brand+",价格为:"+phone.price+",颜色是:"+phone.color+",手机的内存为:"+phone.memory);
System.out.println(phone.playGame("王者荣耀"));
System.out.println(phone.call("刘备"));
phone.weiXin();
System.out.println(phone.study("英语"));
}
}
成员变量和局部变量的区别
1)书写位置不同
局部变量:在方法定义中或者是方法声明上
成员变量:在类中,方法外
2)内置中的位置不同
局部变量:在栈内存中的
成员变量:在堆内存中的
3)生命周期不同
局部变量:随着方法调用而存在,随着方法调用结束立即消失
成员变量:随着对象的创建而存在,随着对象的创建完毕等待垃圾回收器空闲时候进行回收而消失,不会立即消失;
4)初始化不同
局部变量:
要么先定义,然后在使用之前进行数据初始化
要么直接定义并初始化
成员变量:
可以不进行初始化,当对象创建完毕后,系统会默认进行初始化;
我们也可以通过"显示初始化"进行初始化
形式参数问题_研究引用类型
形式参数的问题：
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数
匿名对象
匿名对象:没有名字的对象
创建对象格式:
类名 对象名 = new 类名();
Iphone i = new Iphone();
匿名对象的格式:
new 类名();
访问类的成员变量
new 类名().成员变量名;
访问类的成员方法
new 类名.成员方法();
匿名对象的好处
1)节省内存空间
2)开发中,匿名对象一般使用一次即可,使用完毕就立即垃圾回收器回收
3)手机移动端/Android/鸿蒙系统:基于Java语言
ios系统基于C语言
举例:
//学生类
class Student{
public void study(){
System.out.println("好好学习,天天向上...") ;
}
}
//定义一个类:StudentDemo
class StudentDemo{
//show方法里面形式参数是引用类型:具体的类Student
public void show(Student s){
s.study() ;//new Student().study();
}
}
//测试类
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()) ;
}
}
封装
封装的定义:
private:私有的,不能直接访问的;
特点:
被private修饰的成员变量或者是成员方法,只能在本类中访问;
外界类是不能直接访问的,间接可以通过公共的成员方法访问!
权限修饰符: private(最小) public(最大)
为了保证类的属性的安全性,所有的属性都必须加入private关键字,
并且对外提供公共的访问方法间接的对成员变量(属性)进行赋值;
setXXX()/getXXX():都是public的:权限足够大
属性私有化,对外提供给公共的成员方法访问方法:setXXX()/getXXX()
举例:
举例:
有一个User类.对象这个类进行封装
private String username ;//用户名
private String password ; //密码
private Date birthday;//Date:java.util.Date(日期类:常用类中讲) 出生日期
private String email ;//邮箱
private String activeCode ;//激活码(默认没有激活,不能登录的)
....
setXXX()/getXXX()
现在:UserTest类
自己通过setXXX(赋值)
User user = new User() ;
user.setUsername("张三") ;
//以后:这些数据 可以存在文件中(集合中/IO流)---->数据库(mysql/oralce)
//user.username = "张三" ;私有化了 ,不能直接访问
this是什么,它的作用是什么
this:代表当前类对象的地址值引用
作用:我们通过setXXX()方法赋值的时候,局部变量和成员变量名称一致,导致局部变量隐藏了成员变量,这个时候加入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("这是带两个参数的有参构造方法....") ;
}
}
注意事项:
1)当我们开发者既没有提供无参构造方法,也没有提供有参构造方法,
系统永远给我们提供 "无参构造方法"
类名 对象名 = new 类名() ; //创建对象的格式
2)如果我们提供了有参构造方法,那么系统不会在提供无参构造方法
构造方法的作用:给类的成员属性可以进行数据初始化
给成员变量(私有修饰)赋值几种方式:
1)公共的访问方法setXXX(xx):赋值
2)有参构造方法进行赋值
public 类名(参数类型1 变量名1,参数类名2 变量名2...){
this.成员变量名1 = 变量1;
this.成员变量名2 = 变量2 ;
...
}
仅仅是在类中提供有参构造方法,无参没有给出,系统不会默认提供了
异常: 无法将类中的构造器 应用到给定类型;
标准类的写法
class Phone{
//成员私有化
private String brand;
private int price;
private String color;
private int memory;
//无参构造方法
public Phone(){
}
//有参构造方法
public Phone(String brand,int price,String color,int memory){
this.brand = brand;
this.price = price;
this.color = color;
this.memory = memory;
}
//对外的公共访问方法setXXX(xx)/getXXX()
public void setBrand(String brand){
this.brand = brand;
}
public String gteBrand(){
return brand;
}
public void setPrice(int price){
this.price = price;
}
public int gtePrice(){
return price;
}
public void setColor(String color){
this.color = color;
}
public String gteColor(){
return color;
}
public void setMemory(int memory){
this.memory = memory;
}
public int getMemory(){
return memory;
}
//其他的成员方法
public void call(){
System.out.println("手机可以用来打电话");
}
public void play(){
System.out.println("手机可以用来打游戏");
}
}
class PhoneTest{
public static void main(String [] args){
//无参构造方法
Phone p = new Phone();
p.setBrand("华为");
p.setPrice(4999);
p.setColor("玫瑰金");
p.setMemory(256);
System.out.println(p.gteBrand()+"-----"+p.gtePrice()+"-----"
+p.gteColor()+"-----"+p.getMemory());
p.call();
p.play();
System.out.println("--------------");
//有参构造方法
Phone p2 = new Phone("小米",3999,"星空蓝",128);
System.out.println(p2.gteBrand()+"-----"+p2.gtePrice()+"-----"
+p2.gteColor()+"-----"+p2.getMemory());
p2.call();
p2.play();
}
}
