方法入参和返回值

1.方法入参和返回

　　方法入参

　　　　基础数据类型

　　　　引用数据类型

修饰符 返回类型 ⽅法名(参数类型 参数名,参数类型 参数名...){

 //⽅法体

 return
}

方法返回类型

return xxx 具体类型

如果不⽤返回，则⽅法返回类型上写 void

修饰符 void ⽅法名(参数类型 参数名,参数类型 参数名...){

 //⽅法体

}

2.基础运算符

算术运算符:

加法 +
减法 -
乘法 *
除法 /
取余 %

⾃增1 ++
    a++ 就是 a=a+1
⾃减1 --
    a-- 就是 a=a-1
int a = 5;
int b = a++;
int c = ++a;
int d = a--;
int e = --a;

注意：⾃增（++）⾃减（--）运算符是⼀种特殊的算术运算符

　　    ⾃增（++）⾃减（—）在变量左右有不同的意义

　　　　　在变量左边则先⾃增减操作，再进⾏表达式运算

　　　　　在变量右边则先进⾏表达式运算，在进⾏⾃增减操作

　　　⾃增和⾃减运算符只能⽤于操作变量，不能直接⽤于操作数值或常量

关系运算符（⽤于数值的⽐较，不能是字符串等其他⾮数值）

等号 ==
不等 !=
⼤于 >
⼤于或等于 >=
⼩于 <
⼩于或等于 <=

3.运算符和优先级

　　逻辑运算符

　　　　逻辑与 &&

　　　　　　仅当两个操作数都为真，条件才为真

　　　　　　有短路作⽤

　　　　逻辑或 ||

　　　　　　任何两个操作数任何⼀个为真，条件为真

　　　　　　有短路作⽤

　　　　逻辑⾮ ！

　　　　　　反转操作数，如果条件为true，则逻辑⾮运算符将得到false

赋值运算符

赋值 =
加和赋值 + =
减和赋值 - =
乘和赋值 * =
除和赋值 / =
int a=5;
int c=10;
// c=c+a;
c +=a;
//c =c-a;
c -=a;
//c =c*a;
c *=a;
//c=c/a
c /=a;

三⽬运算符

格式
 条件 ? 成功 : 否则

例⼦
 int age =5;
 age > 18? "成年": "未成年";

运算符优先级

和数学运算⼀样，可以加括号控制优先级
乘除取余 * / %
加减 + -
关系运算>, >=, <,<=
相等 ==、!=
逻辑与 &&
逻辑或 ||
三⽬运算 ? :
赋值 =

4.while循环

　　循环退出

break 关键字
跳出当前层的循环体，执⾏循环体下⾯的语句
重要：字符串⽐较是否相等，不能⽤ ==，应该是⽤ equals⽅法

　　循环跳过

continue 关键字
跳过当前循环，执⾏下⼀次循环, (忽略当前循环内容，直接执⾏下⼀次)

　　多种循环的实现方式总结

// while 循环
while(布尔表达式){
}
// do while循环
do{
}while(布尔表达式);
// 普通for 循环
for(初始化; 布尔表达式; 变量更新){
}
// 增强for 循环
for(声明变量类型： 集合或者数组){
}

int i = 1;
    while (i<=5){
        System.out.println(i);
        i++;
    }

import java.util.*;
Scanner input = new Scanner(System.in);
        String answer;
        do{
            System.out.println("上机编程");
            System.out.println("合格了吗");
            answer = input.next();
            System.out.println("");
        }while(!"y".equals(answer));
        System.out.println("恭喜通过了测试");

while 与 do while 循环 的不同点是 do -while循环是先执行一次 在判断  while循环是先判断在执行while循环是如果条件不成立一次都不执行

int [] integers = {1,2,3,4};
for (int j=0;j<integers.length;j++){
　　int i = integers[j];
    System.out.println(i);
}

String[] strings = {"A","B","C","D"};
        Collection stringList = java.util.Arrays.asList(strings);
        for (Iterator itr = stringList.iterator();itr.hasNext();){
            Object str = itr.next();
            System.out.println(str);
        }

5.if else条件语句

if语句的使用

//如果布尔表达式为true，则执⾏花括号⾥⾯的内容，如果语句体只有⼀句，则花括号可以不
写，但是推荐写
if(布尔表达式){
 //语句体
}

int a = 5;
if(a>1){
　　System.out.println("ok");
}

if else 语句的使⽤，如果if条件为false，则else⾥⾯的内容会被执⾏

int a = 5;
if(a>11){
　　System.out.println("ok");
}else{
　　System.out.println("no");
}

if else if else 语句的使⽤，⽤于判断多个条件

if(布尔表达式1){
 //语句体
}else if(布尔表达式2){
 //语句体
}else if(布尔表达式3){
 //语句体
}else if(布尔表达式4){
 //语句体
}else{
 //语句体
}

注意

　　if 语句⾄多有 1 个 else 语句，可以0个else，且else 语句在最后，类似前⾯的都不成 功，最后⼀定执⾏

　　if 语句可以有多个 else if 语句，它们必须在 else 语句之前

　　如果其中⼀个 else if 语句为 true，其他的 else if 以及 else 语句都将跳过执⾏

if else 嵌套

　　可以在if else⾥⾯嵌套多层if else

int age = 30;
if(age > 10){
 if(age > 18){
 if(age>25){

 }else{

 }
 }else{

 }
}else{

}

switch条件分支语句

条件语句 switch case ,根据分⽀执⾏对应的逻辑
switch(表达式){
 case 表达式常量1:语句1;
 break;
 case 表达式常量2:语句2;
 break;

 ...

 //可以有任意数量的case语句
 case 表达式常量n:语句n;
 break;

 default : //可选
 //语句
}

Switch和if语句都是Java的选择语句，这两种都是允许在程序运⾏时控制程序的执⾏过程。

switch 语句可以拥有多个 case 语句，每个 case 后⾯跟⼀个常量和冒号

default就是如果没有符合的case 就执⾏它,default并不是必须的。

当遇到break语句时，switch语句终⽌。程序跳转到switch语句后⾯的语句执⾏

case语句不必须包含break语句, 没有break语句，程序会执⾏下⼀条case语句，直到出现break语 句为⽌

jdk7之前 switch的case语句⽀持int，short，byte，char类型的值，jdk7后⽀持String类型

int value = 1;
String day;
switch (value) {
　　case 1: day = "周一";
   　　break;
   case 2: day = "周二";
      break;
   case 3: day = "周三";
      break;
   case 4: day = "周四";
      break;
   case 5: day = "周五";
      break;
   default:day = "Invalid month";
      break;
  }
  System.out.println(day);

选择问题：如果只是简单的选择语句 if else即可，复杂或者条件超过4个，则⽤switch语句

6.static静态代码块和静态方法

static关键字

　　static 修饰的⽅法或变量，优先于对象执⾏，所以内存有会现有 static修饰的内容，后有对 象的内容

　　可以⽤来修饰类的成员⽅法、类的成员变量，还可以编写static静态代码块

　　修饰变量就是类变量，修饰⽅法就是类⽅法

　　总结: 类变量或者类⽅法，可以直接通过类名.⽅法名或者变量名进⾏调⽤，不⽤经过对象

public class Student{
 static int age;
 static String name;
 public static void sleep(){

 }
}

static变量也称作静态变量

　　和⾮静态变量的区别是，静态变量被所有的对象所共享，在内存中只有⼀份，它当且仅当在 类初次加载时会被初始化。⾮静态变量是对象所拥有的，在创建对象的时候被初始化，存在 多个副本，各个对象拥有的副本互不影响。

　　static成员变量的初始化顺序按照定义的顺序进⾏初始化

static⽅法也称作静态⽅法

　　不依赖于任何对象就可以进⾏访问，类名.⽅法名

　　不能访问类的⾮静态成员变量和⾮静态成员⽅法

注意事项：

　　静态⽅法不能直接访问⾮静态变量

　　静态⽅法当中不能使⽤this

　　核⼼：⼀个类⾥⾯ static修饰的不能访问⾮static修饰的成员或者⽅法，⽽⾮static修饰的可以 访问static修饰的成员或者⽅法

//静态变量
static int age;
//静态⽅法
public static int getAge(){
 return 5;
}

静态代码块

　　加载类的时候，静态代码块会被执⾏⼀次，且只能执⾏⼀次

　　静态内容优先于⾮静态内容，所以静态代码⽐构造⽅法先执⾏

　　使⽤场景：⽤来⼀次性对静态成员变量进⾏赋值，或者类资源初始化等操作

public class 类名{
 static {
 //静态代码块
 }
}

创建100个学⽣对象，id编号为1~100
把编号可以⼤于60的归为⼆组，其他的归为⼀组

学生类

    private int id;
    public int getId(){
        return id;
    }
    public void setId(int id){
        this.id = id;
    }

AnswerTest类

package day2;
import java.util.Arrays;
public class AnswerTest {
    public static void main(String [] args){
        test1();
    }
    public static void test1(){
        Student[] arr1 = new Student[60];
        int arr1Index = 0;
        Student[] arr2 = new Student[40];
        int arr2Index = 0;
        for(int i=0; i<100; i++){
            int num = i+1;
            Student student = new Student();
            student.setId(num);
            if(num >60){
                arr2[arr2Index] = student;
                arr2Index++;
            }else {
                arr1[arr1Index] = student;
                arr1Index++;
            }

        }
        for(Student s: arr1){
            System.out.println(s.getId());
        }
        System.out.println("==============");
        for(Student s: arr2){
            System.out.println(s.getId());
        }
    }

}

定义⼀个⽅法，给1~4其中⼀个数字，返回春夏秋冬 字符串，不命中则返回 错误季节

package day2;
import java.util.Arrays;
import java.util.Scanner;

public class AnswerTest {
    public static void main(String [] args){
        test2();

    }
    public static void test2(){
        Scanner input = new Scanner(System.in);
        String season;
        System.out.println("请输入数字：");
        season = input.next();
        System.out.println("");
        String content;
        switch (season){
            case "1":content="春";
                break;
            case "2":content="夏";
                break;
            case "3":content="秋";
                break;
            case "4":content="冬";
                break;
            default:{
                content="错误季节";
                System.out.println("default 执行");
            }
        }
        System.out.println(content);
    }
}

定义⼀个Dog类，⾥⾯含有 age 静态变量初始为 10，有⼀个name成员属性 , 有⼀个changeAge⽅法，使age⾃增1， 创建含5个dog的数组，获取数组⻆标为3的dog对象,调⽤两次changeAge⽅法，最后打印5个dog对象的age分别是多少

dog类

package day2;

public class Dog {
    public static int age = 10;
    private String name;

    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }

    public void changeAge(){
        age++;
    }

    public int getAge(){
        return age;
    }
}

AnswerTest类

package day2;
import java.util.Arrays;
import java.util.Scanner;

public class AnswerTest {
    public static void main(String [] args){
        test3();
    }
    public static void test3(){
        Dog [] dogs = new Dog[5];
        for(int i=0; i<5;i++){
            Dog dog = new Dog();
            dog.setName("旺财"+i);
            dogs[i] = dog;
        }
        Dog dog = dogs[3];
        dog.changeAge();
        dog.changeAge();
        for (Dog d:dogs){
            System.out.println("名称="+d.getName()+"，年龄="+d.getAge());
        }
    }
}