为什么有函数的存在
：解决那些重复且具有独立功能的代码段
例如石头剪刀布的题在对com和usr的所出的是什么进行标注的是后，两个switch的功能是一样的。
将这些具有独立功能的代码进行独立的代码进行封装，封装的结果得到一个函数；
降低了代码冗余，冗余（有大量的无用的代码），降低了主函数的代码量，将主函数进行适当的拆分，以便于内存优化，
就是将主函数模块化。
如何去定义一个函数
格式
访问权限 函数类型 返回值类型 函数名（函数列表）{函数体
return 返回值；
}
访问权限
：指的是函数的适用范围（内部和外部）
常见关键字 public protected 默认（就是什么也不写）private
函数类型分类： 说的是函数的使用场景
：static ：静态函数
默认（成员函数）
abstract 抽象函数
native（本地函数）
synchronized 同步函数
函数名
程序员自定义的名称
参数列表：参数列表有若干个参数类型，参数名组成 主要用于接受一些传递给函数的数据
函数体
：那些具有独立功能的代码段
return ：仅仅表示结束当前函数，如果有返回值，则函数结束前将返回值返回给调用者
返回值：函数的计算结果，需要传递给外界 ，配合return使用
返回值类型 就是返回值的数据类型
class Q01{
public static void main(String[] srgs){
public 主函数是公开权
static 主函数是静态函数
void 数没有返回值
main() 主函数的名称
args 就是这个数据类型的变量名称
String 表示的是一个字符串数组
当我们在一个函数中么有找到return，并非指return没有 而是因为无返回值所以不用写，return 本是时表示结束当函数，如果函数有返回值，那么就必须是return 返回值。
需求计算a的b次幂（b是整数）
2^6
double sum=1;
for(int i=1;i<=6;i++)
sum*=2;
5^8
double sum=1;
for(int i=1;i<8;i++)
sum*=5;
两段代码相似但是去屋外再联系
所以下载定义一个函数
定义时 千万不要在一个函数内部据定义一个函数；只能定义在类里面，python c++中必须将函数定义在主函数前，而在Java中可以定义到主函数后面。
public static double pow(double a,int b){
if(b=0){
return 0;
}
double sum=1;
{for(int i=1;i<Math.abs(b);i++)
sum*=a;
}
return b>0?sum:1/sum;
}
对于return的值要在主函数内定义一个变量去接收 例如
这个函数最终形式应该为
class Q{
public static void main(String[] args){ int a=4;
int b=4;
double c=pow(a,b);//函数的调用并用c来接受这个函数的返回值
System.out.println(c);
}
}
//函数的定义
public static double pow(double a;int b){ if(b=0){
return 1;
}
double sum=1;
for(int i=1;i<b;i++){
sum*=a;
}
return b>0?sum:1/sum;
}
函数的分类 有返回值有参数 有返回值无参数 无返回值无参数 有返回值有参数
注意
有返回值的函 参与运算 输出 赋值
无返回值的函数 仅仅调用
函数传参
/*
基本数据类型传参 传的是常量在常量池中的地址
引用数据类型传参 传的是对象在堆内存中的地址
记住一点，实参——>形参 传的永远是地址
基本数据类型 是原子型数据 就是不可再拆分
引用数据类型 是复合型数据 当前对象数据中，其实还包括了其他更多的子数据
int a,b,c;-> arr [a,b,c]
人：姓名 年龄 性别 身高 体重....
复合型数据 指的就是由多个基本数据或其他引用数据组成的一个数据
形参变量永远不可能去改变实参中已储存的数据地址 除非return 实参且接收
就算形参变量所存储的数据地址被改变 那也是改变形参自己 与实参无关
无非是:
实参本身指向的是一个对象
然后把这个对象的地址传递给了形参
形参就可以通过该地址去堆内存中找对象，可以修改对象中的数据
实参再去访问对象时，对象中的数据就已经被改变
因为实参和形参目前使用操作的都是同一个对象！
终结总结：
无论实参还是形参 实参就是把变量空间所存的地址给了形参而已
他们都是变量！
所以对于变量的修改而言,主要分两种！
1.要么改变该变量空间所存储的地址
int a=3;
a=7;
int[] arr=new int[]{1,2,3};
arr=new int[]{3,2,1};
2.要么改变该变量空间所存储的地址所指向的那个对象中的数据
int[] arr=new int[]{1,2,3};
arr[0]=10;
对与基本数据类型而言，能否支持2操作 不能！
*/参数 调用函数时该函数传递的数叫做实参
在函数中调用的参数时形参
而在定义函数的时候实参讲什么东西传递给了实参
1常量在常量池中的地址
2 对象在内存中的地址
主函数在向函数进行传参的时候，是将数在常量池中的地址给了形参，两个参数没有任何关联，只是存储的地址相同罢了，一旦在函数中对形参进行重新定义那么将没有任何关系
可变长参数
当我们再给一个函数进行传参的时候，如果不确定具体的参数个数的话，可以使用可变长参数（参数的类型必须是相同的）
class Q{
public static void main(String[] args){
System.out.println(a.length);
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}
multiArgument(1,2,3,4,5,6,7);
}
//传入的是不确定个数的int型参数
public static void multiArguments(int a ,int b,int...nums){
//如果是mulitargument(int a ,int...nums,int c) 这样是编译不出来的，所以可变长参数必须在最后，因为输入的数int b 后的都进了可编程中，所以int c 没有值,而且在一个函数的调用中只能出现一个可变长参数
//可变长参数其实就是一个数组
System.out.println("a="+a);
System.out.println("b="+b);
System.out,println(nums.length);
for(int i=0;i<nums.length;i++){
System.out.println(nums[i]+" ");
}
System.out.println();
}
}局部变量
： 在函数中创建的变量称之为局部变量，局部变量仅仅作用于创建它的函数。
函数的栈
：函数和栈的关系相当于储存和内存的关系
在一段代码中
先执行主函数，这是将主函数移到栈中，如果在中韩中进行调用函数，这是究竟新的函数移到栈中进行调用，在运行完毕之后会将函数从栈中弹出，在代码最后虽然没写但是会有一个隐形的return 这是默认的，所以return的作用是将函数总栈中弹出，栈中函数全部被弹出的时候，程序就运行终止了。
Java中基本函数
Math函数
Math.E 常数e
Math.pi 圆周率
（数据类型）Math.abs(a) 求绝对值
Math.ceil(小数) 输出大于该数的最小整数
Math.floor(小数) 输出小于指定数字的最大整数
Math(x,y) 返回 x平方加y平方，应用于求两点之间的距离 其中x=delt x y=delt y
Math.max(a,b) 取两者中最大的
Math.min(a,b) 取两者中最小的
Math.pow(a,b)求成方
Math.sqrt(a) 求开方
Math.random() 求随机0到1之间的随机数数
Math.rint(小数) 四舍五入
Math.round() 四舍五入
2
String
1查询相关
int indexOf(int ch)通过字符找角标，从左到右所查找的元素的以一个的角标，如果查找的是字符串，那么输出的是所查找字符的第一个自负的角标
char charAt(indext)通过角标找字符
(这里的indext指的是一个字符串的角标)
SubString(int beginlnxdex,int endlndex)截取一个字符串的一段返回一个子字符串，如果没有end则默认到结尾
System.out.println(s.substring(0,3));
判断相关
boolean countains()
boolean endwith(字符或字符串)判断某个字符串是否是有所输入的字符串结尾的
boolean startwith(字符或字符串)判断某字符串是否是有所输入的字符串开始的
int boolean compareTo（another String） 比较两个字符串大小是否相等比较的是两个字符串在ascll代码中的大小是否相等，返回值有三种答案
整数 前者在后者之后
0表示相等
负数表示前者在后者之前
boolean equals(anotherString)表示两个字符串内容是否相等
boolean equalsIgnoreCase(String anotherString)
对两个字符进行进行忽略大小写进行比较
boolean isEmpty()判断是否为空串
修改相关
String replace(char oldchar,char newchar)
对字符串的修改永远都不是对其自身的修改，也就是是说字符串本身是不可变的，而对字符串的修改往往都是新建字符串，然后将修改后的内容进行赋值。
String toUpperCase 小写转大写
String ToLowerCase 大写转小写
String trim() 返回删掉字符串线面和后面的空格
问题1
求s1在s2中出现的次数
class Q{
public static void main(String[] args){
String s1="abcabcabcabcabcbcabc";
String s2="abc";
int count=0;
for(i=0;i<s1.length()-s2.length;i++){
String sub=s1.subring(i,i+s2,length());
if(sub.equals(s2){
count++;
}
}
System.out.println("s1在s2中出现了"+count+"次")；
}
}判断一个字符串是否回文
class Q{
public static void main(String[] args){
String s="上海自来水来自海上"；
int left=0;
int righs.length()-1;
boolean flag=true;
while(true){
if(s.charAt(left)==s.charAt(right)){
left++;
right--;
if(left>right){
break;
}
}
}
System.out.println("s is huiwen"+true)
}
}
问题3
模拟trim功能
class Q{
public static void main(String[] args){
int left=0;
int right=s.length()-1;
while(s.charAt(left)==' '){
left++;
}
while(s.charAt(right)==' '){
right++;
}
String res=s.substring(left,right+1);
System.out.println("["+res+"]");
}
}问题4
求s1和s2中最大的相同字串（s1长于s2）
s1=“python is a program lauguage but is slow”
s2=“java is a program lauguage but is fast”
class Q{
public static void main(String[] args){
String s1="python is a program lauguage but is slow"
String s2="java is a program lauguage but is fast"
boolean flag=true;
for(int len=s2.length();len>=1;len--){
for(int i=0,j=len-1;j<s2.leng.th;i++,j++){
String sub=s2.substring(i,j+1);if(s1.countains(sub)){
flag=false;
System.out.println("the result is "+sub);
break;
}
}
}
}
}
取绝对值函数
class Q{
public static void main(String[] args){
int a=-1;
int b=-6;
int c=a+b;
System.out.println(Math.abs(c));
}
}
指数函数
class Q{
public static void main(String[] args){ int a=2;
int b=3;
System.out.println(Math.pow(a,b));
}
}
练习
import java.util.*;
public class ti41 {
public static int add(int n)
{
int sum = 0;//计入每一位相加的和
while (n!=0)
sum += n%10;
n/=10;
}
return sum;//返回数字
}
public static void main(String[] args) {
Scanner in = new Scanner(System. in);
int num = in. nextInt();
System. out .println(add(num));//调用函数
}
import java. util . Scanner;
public class ti42 {
static int num ;
public static void reverse(int num)
{
int k = 0,r,l = num;
while (num!=0)//将数字反过来
r = num%10;
k =k*10+r;
num/=10;
}
if(huiwen(k))//和原数字进行比较判断是否为回文数
{
System. out. println(1+"是回文数");
}
else
{
System. out . println(1+"不是回文数");
}
}
public static boolean huiwen (int a)
{
return num==a?true:false;
public static void main(String[] args) {
Scanner in = new Scanner (System. in);
num = in. nextInt();
reverse(num);//调用函数
import java. util . Scanner;
public class ti43 {
public static void go(int n )
for (int i = 1;i<=n;i++)
{
for (int j = 1;j<=n-i;j++)//输出图形
{
System.out.print(" ");
}
for (int k = i;k>0;k--)
{
System. out . print(k);
}
System. out . println();
}
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in. nextInt();
go(n);//传入函数
}
import java.util.*;
class Q404{
public static void main(String[] args){
Scanner scanner = new Scanner(system.in);
System.out.println("enter the password");
String password =scanner.nextline;
if(isValid(password)){
System.out.println("Valid");
}
else{
System.out.println("unvalid")'
}
}
public static boolean isValid(String s){
return islengthValid(s)&&contentValid(s)&&idNumberValid(s);
}
public static Boolean lengethValid(String s){
return s.length()<=8;
}
public static boolean isContentValid(String s){
charc = ' ';
for(int i=0;i<s.length.i++){
c = s.charAt(i);
if(!isLetter(c)&&!isDigit(c)){//！isletter 指的是非 isletter
return false;
}
}
return ture;
}
public static boolean isNumberValid(String s){
int count = 0;
char c = ' ';
for(int i=0;i<s.lengrth;i++){
c = s.charAt(i);
if(isDigit(c)){
count++;
}
}
return count>=2;
}
public static boolean isLetter(String s){//是否是字母
return c>='a'&&c<='z'||c>='A'&&c<='Z';
}
public static boolean isDigit(char c){//是否是数字
return c>='0'&&c,='9';
}
}
import java. util . Scanner;
public class ti45 {
public static double sqrt(double n)
{
double last = 1;
double next = (last +n/last)/2;//套入公式
for ( ;Math. abs(next - last)>1e-6;)//两个差特别小时候结束循环
{
last = next;//这里 需要转换
next = (last +n/last)/2;
return next ;
}
public static void main(String[] args) {
Scanner in = new Scanner (System. in);
double n = in. nextDouble();
System. out .print(sqrt(n));//输出函数返回的值
}
public class ti46 {
public static boolean reverse(int num)//计算这 个数字的倒过来的数字
int k = 0,r,l = num;
while (num!=0)
r =num%10;
k = k*10+r;
num/=10;
return huiwen(k,1)?true:false;
public static boolean huiwen (int a,int 1)//判断是否为回文数
{
return l==a?true:false;
public static boolean su(int n)//判断是否为素数
boolean k = true;
for (int i = 2;i<=n/2;i++)
{
if (n%i==0)
k = false;
break;
}
}
return k == true?true:false;
}
public static void main(String [ ]args)
{
int count = 0;
for (int i =2;count<100;i++)
if (reverse(i )&&su(i))
{
count ++;//计数器
if (count%10==0)
{
System. out . printf("%- 7d\n" ,i);//- :个数字七个单位
}43
else
System. out. printf("%-7d",i);
}
}
}
}
public class ti47 {
public static boolean reverse(int num)//判断他的数字到过来
{
int k=0,r,1=num;
while (num!=0)
{
r = num%10;
k = k*10+r;
num/=10;
}
return huiwen(k, l) ?true:false;
public static boolean huiwen (int a,int 1)// 判断是否为回文数
{
return l==a?true :false;
}
public static boolean su(int n)//判断是否为素数
{
boolean k = true;
for (int i = 2;i<=n/2;i++)
{
if (n%i==0)
{
k = false;
break;
}
return k == true?true:false;
}
public static int fan(int n)
{
int k = 0,r;
while (n!=0){
r = n%10;
k = k*10+r;
n/=10;]
}
return k;
public static void main(String []args)
{
int count = 0;
for (int i =2;count<100;i++)
{
if (!reverse(i)&&su(i))
{
if (su(fan(i)))
{
count ++;}
if (count %10==0)
System. out . printf("% - 7d\n" ,i)
}
else {
System. out .printf("%- 7d",i);}
}
}
import java.util.*;
class Q408{
public static void main(String[] args){
Scanner scanner=new Scanner(System,in);
String str=scanner.next;
char s=scanner.next().char(0);
System.out.println(count(s,a));
}
public static Int count(String a,char b){
int count=0;
if(a.charAt(i)==b){
count++;
}
return count;
}
}
import java.util.*;
class Q409{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
System.out.println("enter nums");
String str=scanner.next();
for(int i=str.length();i>0;i--){
System.out.println(str.charAt(i));
}
}
}
import java.util.*;
class Q410{
public static void main(String[] args){
Scanner scanner=new Scanner.(System.in);
String str=scanner.next();
for(int i=0;i<str.length();i++){
if('A'<=str.charAt(i)&&str.charAt(i)<='Z';
count++;
}
}
}
import java.util.*;
class Q411{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
String a=arr.length()>arr_length()?arr.length():arr_1.length();
String b=arr.length()<arr_1.length()?arr.length():arr_1.length();//b is smaller a is larger;
String arr=scanner.next();
String arr_1=scanner.next();
for(int i=b.length;i>0;i--){
if(a.SubString(0,i)==b.SubString(0,i)){
System.out.println(a.SubString(0,i))
break;
}
}
}
}
}
import java.util.*;
public static void main(String[] args){
System.out.println("enter hexadecimal");
Scanner scanner =new Scanner(System.in);
String str =scanner,next();
int sum=0;
for(int i=0;i<str.length();i++){
sum=sum+str.charAt(i)*(int)Math.pow(16,(i-1));
}
System.out.println(sum);
}
扫一扫
2314
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
