Java基础学习2_java统计学生人数count-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_70761865/article/details/126041449

–方法(break,continue)

方法的使用（Java 方法 | 菜鸟教程 (runoob.com)）

为什么需要使用方法在编写代码的过程中会有许多重复的代码，可以使用方法将重复的代码写进去。

1.1我们经常使用到 System.out.println()，那么它是什么呢？

println() 是一个方法。
System 是系统类。
out 是标准输出对象。

1.2方法的定义

	修饰符 返回值类型 方法名（参数类型）{
	方法体
       return 返回值;
}

在这里插入图片描述

1.2.1无参无返回值的方法

public calss Demo01{
    public static void main(String[] args){
        printT1();
    }
    public static void printT1(){
        System.out.println("无参无返回值");
    }
}

1.2.2无参有返回值的方法

public calss Demo01{
    public static void main(String[] args){
       String str= printT1();
    }
    public static String printT1(){
        //System.out.println("无参有返回值");
        return "无参有返回值"；
    }
}

1.2.3有参无返回值的方法

public calss Demo01{
    public static void main(String[] args){
        printT1(12);
    }
    public static void printT1(int a){
        System.out.println("有参无返回值"+a);
    }
}

1.2.4有参有返回值的方法

public calss Demo01{
    public static void main(String[] args){
        int max=printT1(a,b);
        System.out.println("最大值是"+max);
    }
    public static int printT1(int a,int b){
        if(a<b){
            return b;
        }else{
            return a;
        }
    }
}

2.break和continue

2.1break

跳出循环，结束循环

用法:

1.break用于switch语句中，终止switch语句
2.break用于循环时，跳出循环
3.break用于其他位置，毫无意义

2.2continue

跳过本次循环进入下一次循环。

1.continue用在循环中，跳出本次循环，继续执行下一次循环
2.continue用在其他地方毫无意义

Week02–day02–数组

1.数组概念

：容器概念 容器：是将多个数据存储到一起，每个数据称为该容器的元素。

:数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致

2.数组定义

有三种定义方式

2.1方式一

格式：数组存储的数据类型[] 数组名字 =new 数组存储的数据类型[长度];

int[] arr= new int[5];

数组定义格式详解：

数组存储的数据类型：创建的数组容器可以存储什么数据类型。
[] : 表示数组。
数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。
new：关键字，创建数组使用的关键字。
数组存储的数据类型：创建的数组容器可以存储什么数据类型。
[长度]：数组的长度，表示数组容器中可以存储多少个元素。
注意：数组有定长特性，长度一旦指定，不可更改。
和水杯道理相同，买了一个2升的水杯，总容量就是2升，不能多也不能少。

2.2方式二

格式：数组存储的数据类型[] 数组名字 ={元素1,元素2,元素3...};

2.3方式三

格式：数组存储的数据类型[] 数组名字 =new 数据类型[]{元素1,元素2,元素3...};

3.数组的常见操作

3.1.数组越界异常

public static void main(String[] args) {
	int[] arr = {1,2,3};
	System.out.println(arr[3]);
}
/**创建数组，赋值3个元素，数组的索引就是0，1，2，没有3索引，因此我们不能访问数组中不存在的索引，程序运行后，将会抛出 ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。*/

3.2.数组空指针异常

public static void main(String[] args) {
int[] arr = {1,2,3};
arr = null;
System.out.println(arr[0]);
arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 NullPointerException 空指针异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

3.3数组作为方法的参数

```java
//数组作为方法参数传递，传递的参数是数组内存的地址。
public static void main(String[] args) {
int[] arr = { 1, 3, 5, 7, 9 };
//调用方法，传递数组
printArray(arr);
}
/*
创建方法，方法接收数组类型的参数
进行数组的遍历
*/
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}

在这里插入图片描述

3.4数组作为返回值

//数组作为方法的返回值，返回的是数组的内存地址
public static void main(String[] args) {
	//调用方法，接收数组的返回值
	//接收到的是数组的内存地址
	int[] arr = getArray(); 
	for (int i = 0; i < arr.length; i++) {
		System.out.println(arr[i]);
	}
}
/*
创建方法，返回值是数组类型
return返回数组的地址
*/
public static int[] getArray() {
int[] arr = { 1, 3, 5, 7, 9 };
//返回数组的地址，返回到调用者
return arr;
}
```![在这里插入图片描述](https://img-blog.csdnimg.cn/bb9c62a07a3c46cdb7e772263afe54f3.png#pic_center)

# week02--day03--排序

## 冒泡排序

> [(406条消息) 超详细十大经典排序算法总结（java代码）c或者cpp的也可以明白_Top_Spirit的博客-优快云博客_排序算法汇总](https://blog.csdn.net/weixin_41190227/article/details/86600821?ops_request_misc=%7B%22request%5Fid%22%3A%22165828369416781647583065%22%2C%22scm%22%3A%2220140713.130102334..%22%7D&request_id=165828369416781647583065&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-86600821-null-null.142^v32^pc_search_result_control_group,185^v2^control&utm_term=排序算法&spm=1018.2226.3001.4187)

1)比较相邻的元素。如果第一个比第二个大，就交换它们两个。
2）对每一对相邻的元素都进行比较，等所有的比较完后最后一个数字是这堆数据里的最大数字。
3）重复步骤一，直到排序完成。![image](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9pbWFnZXMyMDE3LmNuYmxvZ3MuY29tL2Jsb2cvODQ5NTg5LzIwMTcxMC84NDk1ODktMjAxNzEwMTUyMjMyMzg0NDktMjE0NjE2OTE5Ny5naWY)

```java
/**
     * 冒泡排序
     *
     * @param array
     * @return
     */
    public static int[] bubbleSort(int[] array) {
        if (array.length == 0)
            return array;
        for (int i = 0; i < array.length; i++)
            for (int j = 0; j < array.length - 1 - i; j++)
                if (array[j + 1] < array[j]) {
                    int temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
        return array;
    }

选择排序

public class Demo{
    public static void main(String[] args){
        int[] arr={1,23,556,0,56,43,345,34};
        for(int i=0;i<arr.length-1;i++){
            int index=i;
            for(int j=i+1;j<arr.length;j++){
                if(arr[index]>arr[j]){
                    index=j;
                }
                int temp= arr[index];
                arr[index]=arr[i];
                arr[i]=temp;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

Week02–day04–面向对象-01

1.面向对象的两个重要概念

类：是对一切事物的统称。是一个泛泛的概念。可以用来描述事物的特征和行为的

对象:是一个具体的实体。是这是真实存在的。在类的基础之上孵化出来的。

类和对象的关系

类是对一类事物的描述，是抽象的。

对象是一类事物的实例，是具体的。

类是对象的模板，对象是类的实体。

2.声明一个类

public class 类名{
	类的属性；
	类的方法；
}

public class Student{//定义的实体类
 String name;//属性
 int age;
 //默认有一个无参的构造方法
 public void eat(){//定义学生类的行为
     System.out.println("吃小吃");
 }
}

3.对象的创建

创建对象：
类名 对象名= new 类名();//
使用对象访问类的属性和方法
对象名.属性名;
对象名.方法名();

//注意事项:实体类和测试类写在同一个文件中的时候，实体类不能带public修饰符

4.构造方法

注意事项：

如果你不提供构造方法，系统会给出无参数构造方法。
如果你提供了构造方法，系统将不再提供无参数构造方法。
构造方法是可以重载的，既可以定义参数，也可以不定义参数。

4.1无参构造方法

构造方法名与类名相同，并且必须写在实体类中
语法格式
public 类名(){}//无参的构造方法

class Dragon{
	double lengths;
	String name;
	public Dragon() {
		
	}
	public void fly() {
		System.out.println("龙在飞，降雨");
	}
	
}
public class Demo03 {
	
	public static void main(String[] args) {
		Dragon dr=new Dragon();
		dr.lengths=12.2;
		dr.name="龙七";
	}
}

4.2有参构造方法

语法格式
public 类名(参数){
 初始化值;
}
注意：在创建有参构造方法后默认的无参构造方法被重写所以没有了无参构造方法

package com.lxy.qfWeek02_04;
class Dragon{
	double lengths;
	String name;
	public Dragon() {
		
	}
	public void fly() {
		System.out.println("龙在飞，降雨");
	}
	public Dragon(String name) {
		this.name = name;
	}
	
}
public class Demo03 {	
	public static void main(String[] args) {
		Dragon dr=new Dragon();
		dr.lengths=12.2;
		dr.name="龙七";
		Dragon dr1=new Dragon("龙九");
	}
}

5.对象在内存中如何存储的

栈内存：

存的是八大基本数据类型的数据

对象的引用。 =左边

堆内存:

对象的全部数据

5.1一个对象调用一个方法内存图

在这里插入图片描述

通过上图，我们可以理解，在栈内存中运行的方法，遵循"先进后出，后进先出"的原则。变量p指向堆内存中的空间，寻找方法信息，去执行该方法。

但是，这里依然有问题存在。创建多个对象时，如果每个对象内部都保存一份方法信息，这就非常浪费内存了，因为所有对象的方法信息都是一样的。

5.2两个对象调用一个方法内存图

在这里插入图片描述

6.构造代码块

语法格式：
{
	语句体；
}

注意事项：

1.构造代码块必须写在实体类中

2.先执行的是构造代码块在执行构造方法

7.成员变量和局部变量

7.1局部变量

局部变量是定义在方法中或是for循环中的变量

public class Test01 {
	int a;//是全局变量，成员变量
	public void Test01(int b) {//b就是局部变量
		this.a =b;//this.a 是全局变量
	}
}

7.2成员变量

成员变量定义在实体类的下面作用与整个实体类中

7.3成员变量与局部变量的区别

区别	局部变量	成员变量
在类中的位置	方法中或者方法声明上(形式参数)	类中，方法外
作用范围不一样	方法中	类中
初始化值的不同	没有默认值。必须先定义，赋值，最后使用	默认值
内存	栈区	堆区
生命周期	随着方法的调用而存在，随着方法的调用完毕而消失	随着对象的创建而存在，随着对象的消失而消失

Week02–day05–面向对象-02

1.封装

使用 private 关键字来修饰成员变量。
对需要访问的成员变量，提供对应的一对 getXxx 方法、 setXxx 方法。

1.1 封装的操作

private的含义

private是一个权限修饰符，代表最小权限。

可以修饰成员变量和成员方法。

被修饰的成员变量和成员方法，只在本类中才能有访问权限。

private 数据类型 变量名 ；
public class Student {
	private String name;
	private int age;
}
//提供 getXxx 方法 / setXxx 方法，可以访问成员变量，代码如下：
public class Student {
	private String name;
	private int age;
	public void setName(String n) {
		name = n;
	}
	public String getName() {
		return name;
	}
	public void setAge(int a) {
		age = a;
	}
	public int getAge() {
		return age;
	}
}

2.this关键字

注意

this( ) 不能在普通方法中使用，只能写在构造方法中。
在构造方法中使用时，必须是第一条语句。

this代表所在类的当前对象的引用（地址值），即对象自己的引用。记住：方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁。

1.可以调用成员变量可以调用成员方法
2.可以调用构造方法

注意事项：这个用的很少！！！

this()。可以调用构造方法。只能在构造方法中调用构造方法，只能写在第一行

能不能在成员方法中调用构造方法？不能！！！
class Dog {
	String name;
	int age;
	public Dog() {
		System.out.println("123");
		//this("styb", 8);
	}
	public Dog(String name, int age) {
		this();
		System.out.println("有参构造");
	}
	
	
	
}
public class Demo2 {
	public static void main(String[] args) {
		//需求：实例化对象dog  要求将有参构造这四个字打印出来
		Dog dog = new Dog("goudan", 12);
		//Dog dog = new Dog();
	}

}

3.类对象可以作为一个方法的参数

方法的参数可以是八大基本数据类型，String,数组

类对象也是可以的

/**
*需求是老师对应多个同学
*/
class Teacher{
	private String name;
	private int id;
	private Student[] stu1; 
	public Teacher() {}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	
	public Student[] getStu1() {
		return stu1;
	}
	public void setStu1(Student[] stu1) {
		this.stu1 = stu1;
	}
	public Teacher(String name, int id,Student[] stu1) {
		this.id=id;
		this.stu1=stu1;
		this.name=name;
	}
	
	@Override
	public String toString() {
		return "Teacher [name=" + name + ", id=" + id + ", stu1=" + Arrays.toString(stu1) + "]";
	}
	public void command() {
		System.out.println("我是老师");
	}
	
}
class Student{
	private String name;
	private int age;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Student() {}
	public Student(String name , int age) {
		this.age=age;
		this.name=name;
	}
	public void study() {
		System.out.println("我是学生");
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	
}
public class Demo02_Teacher_stu {
	/**
	 * 老师类
	学生类
	老师带了很多学生    把学生存倒数组中 STudent[] stus = new Student[6];
	 * @param args
	 */
	public static void main(String[] args) {
	    String[] name= {"张三","李四","周五","吴六","赵大","钱二"};
	    int[] age= {19,21,23,24,32,12};
	    Student stu[]= {
	    		new Student("张三",14),
	    		new Student("李四",19),
	    		new Student("周五",22),
	    		new Student("吴六",42),
	    		new Student("赵大",22),
	    		new Student("钱二",18)};
	    Teacher teacher = new Teacher();
	    teacher.setId(1);
	    teacher.setName("博哥");
//	    System.out.println(teacher);
	    teacher.setStu1(stu);
	    System.out.println(teacher);    
	}

}

4.多类合作【重点】

一个类对象可以当成另外一个类的成员变量

class Person1 {
	private String name;
	private Cat1 cat1;//一个类对象可以作为另外一个类的属性来使用
	//碰到private修饰的属性有set和get的想法
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Cat1 getCat1() {
		return cat1;
	}
	public void setCat1(Cat1 cat1) {
		this.cat1 = cat1;
	}
	
}
class Cat1 {
	private String name;
	private char sex;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public char getSex() {
		return sex;
	}
	public void setSex(char sex) {
		this.sex = sex;
	}	
}
public class Demo2 {
	public static void main(String[] args) {
		//要对Person1对象的属性进行赋值
		Person1 person1 = new Person1();
		person1.setName("老万");
		Cat1 cat1 = new Cat1();
		cat1.setName("小万");
		cat1.setSex('母');
		person1.setCat1(cat1);
		//取值
		//通过 人取猫的值
		System.out.println(person1.getName());//获取人的名字
		System.out.println(person1.getCat1());//获取猫对象
		System.out.println(person1.getCat1().getName());//获取猫的名字
		System.out.println(person1.getCat1().getSex());
	}

}

package com.lxy.qf2_day05_zuoye;
/**
 * Department Employees
 * @author 吕新炎
 */
class Department{
	private String D_name;
	private Employees  employee;
	public String getD_name() {
		return D_name;
	}
	public void setD_name(String d_name) {
		D_name = d_name;
	}
	public Employees getEmployee() {
		return employee;
	}
	public void setEmployee(Employees employee) {
		this.employee = employee;
	}
	
}
class Employees{
	private String E_name;
	private int age;
	public String getE_name() {
		return E_name;
	}
	public void setE_name(String e_name) {
		E_name = e_name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}
public class Demo01 {
	public static void main(String[] args) {
		Employees employe= new Employees();
		employe.setAge(19);
		employe.setE_name("员工一");
		Department department= new Department();
		department.setEmployee(employe);
		department.setD_name("人力资源部");
		System.out.println(department.getD_name()+"有: "+department.getEmployee().getE_name());
	}
}