1 return关键字
return ：具有返回具体的结果,一般在带有具体返回值类型的方法中使用（不建议单独使用），结合方法使用。
格式；return 返回值；
public class SearchDemo {
public static void main(String[] args) {
int [] arr ={3,5,7,9,6,4};
int result = search(arr,4);//有返回值时，采用赋值调用。
System.out.println(result);
}
public static int search(int [] arr,int key){//两个明确：明确参数类型、明确参数列表个数。
int index = -1;
for (int i = 0; i < arr.length; i++) {
if (arr[i]==key){
index = i;
}
}
return index; //return 返回值，程序遇到return后直接结束main方法并返回index
}
}
2 方法
方法的概念：方法就是将能特定完成某一特定功能的核心代码放进{}（方法区）中，并为其取一个名字（符合标识符命名规则）
2.1 方法的定义格式
方法的定义格式分为两种：
1 有返回值类型
格式：
权限修饰符 static 返回值类型 方法名（形参列表（int a））{
功能区；
return 具体返回值；
}
该方法的具体功能是返回输入数值的出现次数
public static int repeat(int[] arr, int key){//有返回值类型方法的定义格式.
int size =0;
for (int i = 0; i < arr.length; i++) {
if (arr[i] ==key){ //判断有几个重复的值
size++; //计数器
}
}
return size;
}
权限修饰符：public 公开的，表示权限足够大
static：静态变量
int：返回值类型为整型（目前是一些基本类型+数组+String）
方法名、变量名：见名知义，采用“小驼峰”命名法.
2 无返回值类型
格式：权限修饰符 static void 方法名（形参列表）{
输出语句/或者打印数据
}
void 代替了数据类型
3 两个明确
1 明确返回值类型
2 明确参数个数
注意：方法之间是“平级”，不能方法套用方法。
2.2 方法调用格式
1.单独调用：没有输出具体结果，一般建议无返回值类型使用。
2.输出调用：直接将返回结果打印在了控制台（将结果的使用范围写死，不建议使用）
3.赋值调用：将返回值赋予指定变量进行打印，一般建议有返回值类型使用。
例：int result = printArrays(arr);
System.out.println("result:"+result);
2.3 用方法打印九九乘法表
public class PrintMulForn {
public static void main(String[] args) {
printMulForm(); //无返回值类型的单独调用
}
public static void printMulForm(){
for (int i = 1 ; i <= 9 ; i++){ //控制外层循环。（共有九轮（行））
for (int j = 1 ; j <= i ; j++){
//控制内层循环，共有九列，且每列的个数小于等于行数。 System.out.print(i + "*" + j + "=" + (i*j) +"t"); //打印九九乘法表
}
System.out.println(); //每循环完一轮进行换行
}
}
}
n*n乘法表（相同原理）：
import java.util.Scanner;
class NewPrintForm{
public static void main(String [] args){
Scanner sc = new Scanner(System.in);
System.out.println("请随机录入一个数：");
int nums = sc.nextInt();
print(nums);
}
public static void print(int nums){
for(int a =1;a
3 数组
数组：将一串连续且相同的数据存储起来的存储单元。
定义格式：
数据类型 [] 数组名（）;
数据类型 数组名 [];
数据类型（基本类型）
数组初始化：
1.数组动态初始化：
格式: 数据类型 [] 数组名 = new 数据类型[数组长度];推荐使用）; (例：int [] arr = new int[5];)
数据类型 数组名 [] = new 数据类型[数组长度];
(例：int arr[] = new int[5];)
2.数组的静态初始化：我们输入元素，数组默认为其分配长度。
格式: 数据类型 [] 数组名 = new 数据类型 {元素1，元素2，，，，元素n};（推荐）
数据类型 数组名 [] =new 数据类型 {元素1，元素2，，，，元素n};
例：int [] arr = new int{1,2,3,4,5};
简化格式：
数据类型 [] 数组名 = new 数据类型{元素1，元素2，，，元素n};
例：int [] arr ={1,2,3,4,5};
注意：数组要么静态初始化、要么动态初始化，切勿动静结合。
例：int [] arr =new int[3]{1,2,3,4,5}(错误展示)
3.1 遍历数组的固定方法（美化）
public void printArrays(int [] arr){
System.out.print("[");
for (int i = 0; i < arr.length; i++) {//遍历数组
if (i == arr.length-1){ //在arr.length-1处加上“]”
System.out.print(arr[i]+"]");//打印数组及其美化格式
}else {
System.out.print(arr[i]+", ");
}
}
}
输出结果格式为：[1,2,3,4,5]
3.2 求数组最大值、最小值
public static int getMax(int [] arr){
int max =arr[0]; //假想arr[0]为最大值，然后让后面的元素一一和其进行比较，大的值赋给max，最终得出最大值。
for (int i = 0; i < arr.length; i++) {
if (arr[i] > max){
max = arr[i]; //把大的值赋给max
}
}
return max;
}
}
最小值类似（省略。。。）
3.3 数组元素倒置
public static void arraysReverse(int [] arr){
for (int start = 0 , end = arr.length-1 ; start
3.4 数组元素查找
public static int search(int [] arr,int key){
int index = -1;
for (int i = 0; i < arr.length; i++) {
if (arr[i]==key){
index = i; //如果找到数组值就将该值赋值给index
}
}
return index; //如果找不到，返回index=-1，如果找得到，则返回该元素具体下标。
}
4 排序之冒泡排序
思路：将数组中得元素两两之间进行比较，一共比较arr.length-1轮，每轮比较arr.length-i-1次
代码：
public void sortPrintArrays(int [] arr){
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - i -1; j++) {
if (arr[j]>arr[j+1]){
int temp = arr[j]; //定义中间变量来对数组元素进行交换。
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
之后搭配数组遍历方法进行输出。
5 面向对象
1 概念：万物皆对象（仅詹姆斯·高斯林可说），生活中处处皆对象，面向对象是基于面向过程完成的。
例如你吃饭：
面向过程：自己买材料，然后清洗，切菜，开炒，盛到盘子里。
面向对象:直接点个外卖，别人帮你做。
2 面向对象思维：
(1)更符合我们生活中得行为思想特征
(2)复杂的事情简单化
(3)角色发生了变化，我们成了指挥者
5.1 面向对象的设计规则
不断地创建对象、不断地调用对象，不断地指挥对象做事情。
例：
Scanner 对象名 = new Scanner(System.in);
录入数据并且使用数据。（基本类型+String）
5.2 伪代码对比:面向过程/面向对象 （元素倒置/冒泡排序）
面向过程：
1)测试类 main方法所在类
2)分析
定义两个方法：
1.元素倒置方法
2.打印元素方法
public class ArraysReverse {
public static void main(String[] args) {
int [] arr ={1,2,3,4,5,6};
arraysReverse(arr);
printArrays(arr);
}
public static void arraysReverse(int [] arr){
for (int start = 0 , end = arr.length-1 ; start arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
}
public class NewBubble {
public static void main(String[] args) {
int [] arr = {11,33,22,55,66,44};
Bubble bubble = new Bubble();
bubble.sortPrintArrays(arr);
bubble.printArrays(arr);
}
}
5.3 类
概念:能够描述一组事务的行为和属性的集合
代码体现：
public class Student {
String name; //学生的属性
String sex;
int age;
public Student() {
}
public void study(){ //学生行为
System.out.println("正在学习中。。。。");
}
}
调用格式:
在测试类中使用:main方法所在类
代码体现:
格式:
类名 对象名 = new 类名() ;Student s = new Student();
给具体事物属性赋值
对象名.成员变量 = 根据类型赋值; s.sex = "男";
调用具体事物的行为
对象名.成员方法名() ; s.study();
5.4 类的基本使用
5.4.1 描写一个学生类
成员变量：String name ，String sex ，int age ，double score。
成员方法：学习、吃饭
代码：public class StudentTest {
public static void main(String[] args) {
Student student = new Student();
student.name="高圆圆"; //成员变量赋值方式
student.sex ="女";
student.age = 42;
student.score = 97.0;
System.out.println("学生名字为："+student.name+"学生性别为："+student.sex+"学生年龄为："+student.age+"学生分数为："+student.score);
String result = student.study("高圆圆");
System.out.println(result); //有返回值类型传参调用
student.eating(); //无返回值类型单独调用
}
}
class Student{
String name;
String sex;
int age;
double score;
public String study(String name){
return name+"正在努力学习中。。。";
}
public void eating(){
System.out.println(name+"学习累了，正在吃饭中。。。");
}
}
5.4.2 成员变量和局部变量的区别：
定义位置：局部变量定义在方法体内或者方法声明上。
成员变量定义在类中、方法外.
存储位置：局部变量存储在栈内存中
成员变量存在堆内存中
生命周期：局部变量随着方法的调用而产生、随着方法的调用而结束。
成员变量随着对象的创建而产生、随着对象的调用结束而不会被立即回收，等待垃圾回收器回收。
初始化值：局部变量在使用前必须初始化值（定义时赋值也可以）
成员变量随着对象的创建，系统默认对其初始化。
5.4.3 当形参列表中为基本类型或者引用类型时对实际参数的影响:
当形参类型为基本类型（与String）时，形参的改变不会影响实际参数的值。
当形参类型为引用类型时（除String外），形参的改变直接影响实际参数的值（空间地址值传递的方式）。
注意：当形参列表中类型为类时，实际参数需要传递的当前类的具体对象。
5.5 匿名对象
顾名思义，没有名字的对象
创建对象的格式：对象名 类名 = new 对象名();
匿名对象定义格式： new 类名();
使用匿名对象的好处：
1)节省内存空间
2)开发中,匿名对象一般 使用"一次即可",使用完毕就立即垃圾回收器回收。
3)书写格式简单
代码演示:
class Student{
public void study(){
System.out.println("好好学习,天天向上...") ;
}
}
//定义类:StudentDemo
class StudentDemo{
public void show(Student s){
s.study() ;//new Student().study();
}
}
class NoNameDemo{
public static void main(String[] args){
//访问show方法，先创建StudentDemo对象
StudentDemo sd = new StudentDemo() ;
//调用show方法
Student s = new Student() ;
sd.show(s) ; //实际参数需要创建Student类的对象
//访问StudentDemo类中的show方法
StudentDemo sd2 = new StudentDemo() ;
sd2.show(new Student()) ;
}
}
6 封装和this关键字
概念：为了类的属性安全性，定义时在其前面加上private关键字来限制其使用范围，并通过设立setxxx/getxxx方法来进行对其值的访问。（属性私有化、方法公开化）
this关键字：当成员变量和形参列表中的局部变量相同时，我们使用this关键字来加以区分。
代码演示:
class Worker{
private String name; //属性变量私有化
private int age;
private double salary;
public Worker() { //默认构造方法
}
public String getName() { //设立getxxx/setxxx方法对属性进行访问。
return name;
}
public void setName(String name) {
this.name = name; //this关键字：用来区分成员变量和局部变量重名时的问题的。
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public void worker(){
System.out.println("正在工作中...");
}
public void workerTime(String name,int hour){
System.out.println(name+""+"已经工作了"+hour+"小时");
}
}
public class WorkerTest {
public static void main(String[] args) {
Worker w = new Worker();
w.setName("高圆圆");
w.setAge(42) ;
w.setSalary(19999) ;// 使用setxxx方法为其赋值(注意调用的是方法)，使用getxxx方法为其赋值。
System.out.println(w.getName()+"今年："+w.getAge()+"月薪为："+w.getSalary());
w.worker();
w.workerTime("高圆圆",10);
}
}
7 构造方法
概念:构造方法时一种特殊的方法，方法名和类名一致
特点：1）方法名称与类同名
2）无返回值类型（也没有void）
3）构造方法是重载的。
核心代码演示：
class Worker{
private String name;
private int age;
private double salary;
public Worker() {
}
public Worker(String name, int age, double salary) { //对象属性初始化、创建对象时可以直接赋值
this.name = name;
this.age = age;
this.salary = salary;
}
}
给成员变量赋值的方式：
当成员变量的权限修饰符为public，通过类名打点访问成员变量给其赋值即可。
当成员变量的权限修饰符为private：1.通过setxxx/getxxx给其赋值
2.通过构造方法初始化其值，创建对象时为其赋值。
