记住格式
//拿来一个扫描器：
Scanner sc = new Scanner(System.in);
//给一个友好性的提示：
System.out.print("请录入一个半径：");
//让扫描器扫描键盘录入的int类型的数据：
int r = sc.nextInt();
double[] score = new double[10];
double sum=0, max = 0,min =0;
Scanner sc = new Scanner(System.in); //ctr+shift+o导包;alt+/代码提示;ctr+alt+上下键复制
for(int i =0;i<score.length;i++) {
System.out.print("请输入第"+(i+1)+"个同学的成绩：");
score[i] = sc.nextDouble();
//string两种写法
//import java.util.Scanner;
class TestWork604{
public static void main(String[] args){
/**
Scanner sc = new Scanner(System.in);
String s = sc.nextline();
System.out.println(s);
**/
String str = "123454321";
str=str.trim();
boolean flag=isPalindrome(str,0,str.length()-1);
System.out.println("Flag is: "+flag);
}
//spit放入数组
正文
/**
1.java中函数是属于类（class)的，必须定义在类中
2.函数无法自己执行，必须通过调用才可以执行
3.java中：静态方法没有办法直接调用非静态方法，只能调用静态方法
4.有参数的函数，调用时必须传递对应的参数
5.函数中，遇到return则立即结束，并且返回
**/
一.函数定义
/**
java定义函数：
访问修饰符 函数返回子类型|void 函数名称（[参数列表]）{
函数体;
}
**/
二.函数调用
/**
函数调用：
函数名称（[参数列表]）;
重点内容：函数在内存的调用本质
栈：先进后出
队列：先进先出
执行栈：
函数怎么调用
局部变量
/**
局部变量（本地变量）：定义在函数中，作用域是整个函数类，无法跨越
成员变量：在class中 ，作用域是整个类
**/
三.函数分类
/**
函数分类：
有没有参数：
有参数|无参数（未知输入数据；更加灵活）
有没有返回值：
有返回值|无返回值
定义者：
系统函数|第三者|自定义函数
**/
四.代码
//1.函数定义
//1.函数定义
class TestFun{
public static void main(String[] args){
//函数调用
sayHello ();
//注意，在main函数中，如果要调用非静态方法
//必须使用构建对象的方式(面向对象)
//TestFun tf = new TestFun();
//tf.sayHello;
}
public static void sayHello(){
System.out.println("hello, i am function...");
}
}
//2.函数分类
//2.函数分类01
class TestFun{
public static void main(String[] args){
//函数分类
showInfo ('刘莹',20,‘女’);
}
public static void showInfo (String name, int age,char gender)//形参{
System.out.println("name:" + name);
System.out.println("age:" + age);
System.out.println("gender:" + gender);
}
}
//2.函数分类02（返回值）
class TestFun{
public static void main(String[] args){
//将函数的返回值使用变量接受，形参与实参数据类型一致或者强制转换
int a = add(2,8);
System.out.println("2 + 8 =" + a);
}
public static int add(int x,int y) { //没有void则有返回值
return x + y;
}
}
//函数判断一个数是不是素数
//函数判断一个数是不是素数
import java.util.Scanner;
public static void main(String[] args){
Scanner sc = new Scanner(Systeam.in);
System.out.print(">");
int num = sc.nextInt();
boolean Primer = isPrime(num);
if(Primer){
System.out.print("是质数");
}else{
System.out.print("不是质数");
}
}
public static boolean isPrimer(int num){
for(int i =2;i <num / 2 ;++i){
if(num % i == 0){
return false;
}
}
return true;
}
五.函数重载
函数重载（overload）；
函数名称一样 2.函数参数数据类型或者个数不同 3.跟返回值类型无关
面试题:
请简述overload（函数重载）、override（覆盖）、overwrite（重写）
思考：
函数重载所有编程语言都有的吗？
函数重载现象是强数据类型语言（java、C、C++、C#）所特有的现象
弱数据类型语言(javascript、python、ruby)是不具备函数重载
六.函数递归
函数递归（recursion）：===循环 n>100用循环
函数自身调用自身
分治算法的理念
//重点内容：递归时的内存模型：
优点：分治算法的理念，复杂化简
缺点：非常耗费内存(栈溢出异常)，当栈被全部占用后，触发StackOverflowError异常！！！
注意，可以使用java -X -Xss 大小， 来调整JVM的栈大小空间
-Xms<大小> 设置初始 Java 堆大小
-Xmx<大小> 设置最大 Java 堆大小
七.常见的系统类
1.Math
Math:
Math类，是JDK内置的类，Java.lang.Math
Java.lang:这个包，是默认导入的包
2.Random
随机数：
Math.random()
Random类
java.util.Random
3.String
String字符串对象：
在java中，被双引号，引主的内容就叫做字符串
字符串在java中不是基本数据，是对象，引用数据类型。
final修饰的，
字符串是常量，它们的值不能被创建后改变。支持可变字符串字符串缓冲区。
因为字符串对象是不可改变的，所以它们可以被共享。
字符串的各种方法
ToCharArray():将字符串转换成char类型的数组
new string(char[] chs):将一个字符数组转换成一个字符串
ToUpper():表示将一个字符串转换成大写形式。
ToLower():表示将一个字符串转换成小写形式。
Equals(“要比较的字符串”,StringComparison.OrdinalIgnoreCase)：比较字符串，忽略大小写
Split(new char[]{‘要分割的字符串’},StringSplitOption.RemoveEmptyEntries):分割字符串，返回一个字符串类型的数组
Substring():截取字符串
Contains(“要判断的字符串”) 其值为布尔类型 判断是否包含某个字符子串
StartsWith(“要判断的字符串”) 其值为布尔类型 判断是否以某个字符子串开头
EndsWith(“要判断的字符串”) 其值为布尔类型 判断是否以某个字符子串结尾
int IndexOf(string value)：取子串value第一次出现的位置
int LastIndexOf最后一次出现的位置
八.代码
//1.函数重载
class TestOverLoad {
public static void main(String[] args) {
byte a = 20;
add(10, a);
add(100);
add(100, 20.56);
add(20.56, 100);
}
public static int add(int a, int b) {
System.out.println("----------1-------");
return a + b;
}
public static double add(int a, double b) {
System.out.println("----------1-------");
return a + b;
}
public static double add(double a, int b) {
System.out.println("----------1-------");
return a + b;
}
public static double add(double a, double b) {
System.out.println("----------1-------");
return a + b;
}
public static int add(int a, byte b) {
System.out.println("----------2-------");
return a + b;
}
public static int add(int a) {
System.out.println("----------3-------");
return a + 10;
}
}
//2.函数递归
class TestCecursion {
public static void main(String[] args) {
// System.out.println(getCount(100));
System.out.println(getCount2(1000000));
}
/**递归也可，循环也可
public static int getCount(int n) {
int count = 0;
for (int i = 1; i <= n; i++) {
count += i;
}
return count;
}
**/
// 递归 分治算法的理念
public static int getCount2(int n) {
if (n == 1) {
return 1;
}
return n + getCount2(n - 1);
}
//2.1
递归1：求第n项的斐波那契数列值
class TesFibonacii {
public static void main(String[] args) {
System.out.println(getFibo2(10));
}
// 递归方式求斐波那契数列的值？
public static int getFibo(int n) {
if (n == 1 || n == 2) {
return 1;
}
return getFibo(n - 1) + getFibo(n - 2);
}
/**循环实现
public static int getFibo2(int n) {
int first = 1, second = 2;
int temp;
for (int i = 2; i <= n; i++) {
temp = second;
second = first + second;
first = temp;
}
return first;
}
**/
递归1变型：
上楼梯问题：某个人上楼梯，每次只能上一个台阶或者两个台阶，
那么当这个人到达第n个台阶时，共有多少种走法？
// 走楼梯问题
class TestStairs {
public static void main(String[] args) {
System.out.println(getStairs(10));
}
public static int getStairs(int n) {
if (n == 0) {
return 0;
}
if (n == 1) {
return 1;
}
if (n == 2) {
return 2;
}
return getStairs(n - 1) + getStairs(n - 2);
}
}
递归2：
小明的妈妈看到小明今天高考结束，买了一对刚刚出生的小兔子，小兔子需要3个月长大成兔，之后每月生产一对小兔子，假如不考虑小兔子的死亡情况，求第n月共有多少对兔子？
1 1
2 1
3 1
4 2
5 3
6 4
7 6
8 9
9 13
public class TestRabbit {
public static void main(String[] args) {
System.out.println(getCount(14));
Test02.getCount(10);
}
public static int getCount(int n) {
if (n <= 4) {
return 1;
}
return getCount(n - 1) + getCount(n - 4);
}
}
//3.Math
class TestMath {
public static void main(String[] args) {
// 绝对值
System.out.println(Math.abs(5));
// ceil 向上取整
System.out.println(Math.ceil(5.0001));
// floor 向下取整
System.out.println(Math.floor(5.9999));
// 四舍五入
System.out.println(Math.round(5.5));
System.out.println(Math.round(5.4));
// 最大值
System.out.println(Math.max(10, 100));
// 最小值
System.out.println(Math.min(10, -100));
// 幂次方
System.out.println(Math.pow(2, 3));
// random函数返回的了伪随机数：[0 , 1)
System.out.println(Math.random()) ;
}
public static int abs(int n){
return n > 0? n : -n;
}
public static double abs(double n){
return n > 0? n : -n;
}
public static float abs(float n){
return n > 0? n : -n;
}
public static long abs(long n){
return n > 0? n : -n;
}
}
//4.随机数
public static void main(String[] args) {
System.out.println(Math.random());
// 0~10 的随机数
System.out.println((int)(Math.random() * 10));
// 15 ~ 40的 （m,n）随机数（n-m）+最小值m (n>m)
System.out.println((int)(Math.random() * 25) + 15);
System.out.println(randomRange(10, 40));
}
public static int randomRange(int m, int n){
if (m < n) {
return (int)(Math.random()*(n - m)) + m;
} else {
return (int)(Math.random()*(m - n)) + n;
}
}
}
import java.util.Random;
class TestRandom02 {
public static void main(String[] args) {
Random r = new Random();
System.out.println(r.nextBoolean());
System.out.println(r.nextInt());
System.out.println(r.nextInt(10));
}
}
//5.String
class TestString {
public static void main(String[] args) {
String s = "liujianhong";
String ss = "刘帅哥";
String sss = "liujianhong";
// 也可以通过如下方式，String的构造方法构造字符串
String ssss = new String("liujianhong");
System.out.println(s);
System.out.println(ss);
System.out.println(sss);
System.out.println(ssss);
// 就因为如此，所以，字符串不要使用== 判断是否相等
System.out.println(s == sss);
System.out.println(s == ss);
System.out.println(s == ssss);
// equals方法 来判断字符串是否相等
System.out.println(s.equals(ssss));
System.out.println(ssss.equals(sss));
}
}
