java入门学习过程

相遇皆是缘分

初次体验

HelloWorld

public class HelloWorld{
    public static void main(String[] args){
        System.out.println("HelloWorld");
    }
}

基础语法

注释

单选注释		//
多行注释		/* */
文档注释		/** */
    
    
public class HelloWorld {
	//叫做main方法，表示程序的主入口
	public static void main(String []args) {
		/* 叫做输出语句（打印语句）
		/会把小括号里面的内容进行输出打印 */
		System.out.println("HelloWorld");
	}

}

关键字

关键字的字母全部小写
代码编辑器中关键字有颜色标记

1
2
3

public class static 等等都是关键字
 
class 关键字表示定义一个类，后面跟随类名

字面量

数据在程序中的书写格式

字面量类型	说明	举例
整数类型	不带小数点的数字	666 ， -88
小数类型	带小数点的数字	13.14 ， -5.21
字符串类型	用双引号括起来的内容	“HelloWorld” , “黑马程序员”
字符类型	用单引号括起来的，内容只能有一个	‘A’ , ‘0’ , ‘我’
布尔类型	布尔值，表示真假	只有两个值： true , false
空类型	一个特殊的值，空值	值是： null

public class HelloWorld{
    public static void main(String[] args){
    	
    	//整数
        System.out.println(25);
        
        //小数
        System.out.println(1.93);
        
        //字符串
        System.out.println("HelloWorld");
        
        //字符
        System.out.println('男');
        
        //布尔
        System.out.println(true);
        
        //空
        /*
         细节：null不能直接打印
         如果我们要打印null,那么只能用字符串的形式进行打印
         */
        System.out.println("null");
    }
}

扩展点：特殊字符 ‘\t’ ‘\r’ ‘\n’ …

变量

数据类型变量名 = 数据值;

public class HelloWorld{
    public static void main(String[] args){
    	
    	int a = 10;
        int b = 20;
        System.out.println(a);
        System.out.println(a+b);
        
        b=30;
        System.out.println(b);
        
        //在一条语句中，可以定义多个变量
        int d=100 , e=200 , f=300;
        System.out.println(d+e+f);
    }
}

数据类型

数据类型分成：基本数据类型、引用数据类型
注意取值范围
整数和小数取值范围大小关系： double > float > long > int > short > byte

public class HelloWorld{
    public static void main(String[] args){
    	
    	//byte
    	byte b=10;
        System.out.println(b);
        
        //short
        short s=20;
        System.out.println(s);
        
        //short
        int i=30;
        System.out.println(i);
        
        //long
        /*
         如果要定义long类型的变量
         在数据值的后面需要加一个L作为后缀 
         L可以大写，也可以小写
         建议：使用大写
         */
        long n =9999999999L;
        System.out.println(n);
        
        //float
        /*
         定义float类型变量的时候
         数据值也需要加一个F作为后缀
         F可以大写，也可以小写
         建议：使用大写
         */
        float f=10.1F;
        System.out.println(f);
        
        //double
        double d=20.2;
        System.out.println(d);
        
        //char
        char c='中';
        System.out.println(c);
        
        //boolean( true | false )
        boolean o=true;
        System.out.println(o);
        
        
    }
}

小练习

public class HelloWorld{
    public static void main(String[] args){
    	String a="黑马谢广坤";
        int age = 18;
        char b= '男';
        double d= 180.1;
        boolean o= true; // true 单身 || false 不是单身
        System.out.println("姓名："+a);
        System.out.println("年龄："+ age);
        System.out.println("性别："+b);
        System.out.println("身高："+d);
        System.out.println("是否单身："+o); 
    }
}

标识符

就是给类、方法、变量等起的名字

硬性要求：
1.由数字、字母、下划线（_）和美元符（$）组成
2.不能以数字开头
3.不能是关键字
4.区分大小写
    
下面那些正确那些错误？
-------------------    
bj	    b2 	    2b
class   _2b	    #itheima
ak47    Class   helloworld
    


软性要求： 
不按照要求，也不会报错
-
小驼峰命名法：方法、变量
1.标识符是一个单词的时候，全部小写   （name）
2.标识符是由多个单词组成的时候，第一个单词首字母小写，其他首字母大写    (firstName)
-   
大驼峰命名法：类名
1.标识符是一个单词的时候，首字母大写   （Student）
2.标识符是由多个单词组成的时候，每个首字母大写    (FirstName)

键盘录入

Scanner 类：就可以接收键盘输入的数字

1.导包
import java.util.Scanner;			//导包的动作必须出现在类定义的上边

2.创建对象
Scanner sc = new Scanner(System.in); //上面这个格式里面，只有sc是变量名，可以变，其他的都不允许变。

3.接收数据
 int i = sc.nextInt(); 				//左面这个格式里面，只有i是变量名，可以变，其他的都不允许变。



// 1.导包
import java.util.Scanner;
public class HelloWorld{
    public static void main(String[] args){
    	//2.创建对象
    	Scanner sc = new Scanner(System.in);
        
    	System.out.println("请输入整数："); 
    	//3.接收数据
    	int i = sc.nextInt(); 	
    	
    	System.out.println(i); 
        
    }
}

获取随机数

//导包
import java.util.Random;
public class day4 {
    public static void main(String[] args) {
		//2.创建对象
        Random r= new Random();

        //接收数据--随机数
        //默认：范围从0开始 ---- 到N-1结束
        int number = r.nextInt(100); //0~99r
        
        //范围最小、最大加1
        int number = r.nextInt(100)+1;  // 1~100
        System.out.println(number);

    }
}

小练习

// 1.导包
import java.util.Scanner;
public class HelloWorld{
    public static void main(String[] args){
    	//2.创建对象
    	Scanner sc = new Scanner(System.in);
        
    	System.out.println("请输入整数："); 
    	//3.接收数据
    	int i = sc.nextInt(); 	
    	System.out.println(i); 
    	
    	int a = sc.nextInt();
    	System.out.println(a); 
        
    }
}

运算符

算术运算符

package day3;
public class com {
    public static void main(String[] args){


                // +
                System.out.println(3+2);

                // -
                System.out.println(5-1);

                // *
                System.out.println(3*2);

                // /
                System.out.println(6/3);
                System.out.println(10/3);       // 整数之间相除得到整数
                System.out.println(10.0/3);    // 小数参与计算结果不精确

                // %（取余）
                System.out.println(5%2);

                //如果在计算的时候有小数参与
                /*
                结论：
                在代码中，如果有小数参与计算，结果有可能不精确的
                */
                System.out.println(1.1 + 1.01);
                System.out.println(1.1 - 1.01);
                System.out.println(1.1 * 1.01);

    }
}

小练习-数值拆分

键盘录入一个三位数，将其拆分为个位，十位，百位后，打印在控制台

package day3;

import java.util.Scanner;

public class com {
    public static void main(String[] args){

        Scanner sc = new Scanner(System.in);
        int i = sc.nextInt();

        System.out.println("百位："+ i/100);
        System.out.println("十位："+ i%100/10);
        System.out.println("个位："+ i%10);

    }
}

数字相加

取值范围： byte < short < int < long < float < double

隐式转换	强制转换
取值范围小的数值——> 取值范围大的数值	取值范围大的数值——> 取值范围小的数值
byte 、short 、char 在数据运算的时候，会提升为 int 再进行运算	格式：目标数据类型变量名 = （目标数据类型）被强转的数据; double a = 12.3; int b = (int)a;

小练习

问题：请问最终的运算结果是什么类型的？

'隐式转换'    
    
byte b1 = 10;
byte b2 = 20;
result = b1 + b2;  // 数据类型 : int

-----------------------------------------

int i =10;
long n =100L;
double d=20.0;
result = i + n + d;  // 数据类型 : double

-----------------------------------------

byte b = 10;
short s = 20;
long n = 100L;
result = b + s + n;  // 数据类型 : long


'强制转换'   
    
byte b1 = 10;
byte b2 = 20;
byte result = b1 + b2;  //  byte result = (byte)(b1+b2); 
System.out.println(result);  //结果就发生错误了，因为要强制转换的数据过大

字符串相加

当 “+” 操作中出现字符串时，这个 “+” 是字符串连接符，而不是算术运算符了

1
2
3

"123" + 123         // "123456"
    
 1 + 99 + "年黑马"  // "100年黑马"

小练习

//看代码说结果
    
System.out.println( 3.7 + "abc" );	  //  "3.7abc"

System.out.println("abc" + true); 	  //  "abctrue"

System.out.println('中' + "abc" + true); 	  //  "中abctrue"

int age= 18;
System.out.println( "我的年龄是" + age +  "岁"); 	  //  "我的年龄是18岁"

System.out.println( 1 + 2 + "abc" + 2 + 1); 	// "3abc21"



//数值拆分

package day3;

import java.util.Scanner;

public class com {
    public static void main(String[] args){

        Scanner sc = new Scanner(System.in);
        int i = sc.nextInt();

        System.out.println("百位："+ i/100);
        System.out.println("十位："+ i%100/10);
        System.out.println("个位："+ i%10);

    }
}

字符相加

当 “+” 操作中出现字符时，字符将转成ASCLL码值，进行计算

1
2
3

char c='a';
int result = c+0;
System.out.println(result);  // 97

小练习

//看代码说结果
    

System.out.println( 1 + 'a' );		// 98
System.out.println( 'a' + "abc" );	// "aabc"

自增自减运算符

符号	作用	说明
++	加	变量的值加1
–	减	变量的值减1

++ 和 – 既可以放在变量的前边，也可以放在变量的后边
i++ 先用后加 ++i 先加后用

int a = 10;
a++;
System.out.println( a );  // 11
++a;
System.out.println( a );  // 12
a--;
System.out.println( a );  // 11
--a;
System.out.println( a );  // 10

赋值运算符

+= 、 -= 、*= 、 /= 、%= 底层隐藏了一个强制类型转换

   // +=
      int a = 20 ;
      int b = 20;
      // 把a+b,再把结果赋值给左边的变量a
      a+=b;       // a=a+b;
      System.out.println( a );  // 40


//底层隐藏了一个强制类型转换
short s=1;
// short + 运算  short转换为int , int类型 再赋值给 s(short类型) ---- 强制转换为 s(short类型)
s+=1;
System.out.println( s );   // 2

关系运算符

逻辑运算符

&(逻辑与) |(逻辑或) 无论左边是真是假，右边都会判断真假，两边都需要判断，效率偏低

短路逻辑运算符

&&(短路与) 当左边为真时，才会判断右边是否为真; 当左边为假时，不再判断右边是否为真假，整体直接为假
||(短路或) 当左边为真时，不再判断右边是否为真假，整体直接为真 ; 当左边为假时，才会判断右边是否为假
效率高

小练习

package day3;

import java.util.Scanner;

public class com {
    public static void main(String[] args){

        Scanner sc= new Scanner(System.in);
        System.out.println( "请输入两个整数：" );
        int a=sc.nextInt();
        int b=sc.nextInt();
        boolean result= (a==6 || b==6)||((a+b)%6==0) ;
        System.out.println( result );

    }
}

三元运算符

格式：关系表达式?表达式1:表达式2;

求两个数的最大值
int max = a > b ? a:b;


求三个数的最大值
int a=20,b=10,c=30;
int max = a > b ? a:b;
max= max > c ? max:c;
System.out.println( max );

运算符优先级

其他运算符

用于二进制原码、反码、补码

判断和循环

顺序结构

if

格式：
1.
if(关系表达式){
    语句体;
}


if(酒量 > 2){
    System.out.println("小伙子，不错！");
}
----------------------------------------
2.
if(关系表达式){
    语句体;
} else {
    语句体2;
}

----------------------------------------
3.
if(关系表达式1){
    语句体1;
} else if(关系表达式2){
    语句体2;
}
...
else {
    语句体n+1;
}

分支结构

switch

switch(表达式){
    case 值1:语句体1;break;
    case 值2:语句体2;break;
    ...
    default:语句体n+1;break;
}

default 不一定是写在最下面的，我们可以写在任意位置，都是最后执行
default 可以省略，语法不会有问题，但是不建议省略。

-------------------------------------------------------------
    
//jdk12及之后的版本 【switch新特性】
int number = 10;
switch (number){
    case 1 -> {
        System.out.println("一");
    }
    case 2 -> {
        System.out.println("二");
    }
    case 3 -> {
        System.out.println("三");
    }
    default -> { System.out.println("没有这种选项"); }
}

小练习

package day4;

import java.util.Scanner;

public class day4 {
    public static void main(String[] args) {
        Scanner sc= new Scanner(System.in);

        int day = sc.nextInt();
        switch (day){
            case 1:
            case 2:
            case 3:
            case 4:
            case 5: System.out.println("工作日");break;
            case 6:
            case 7: System.out.println("休息日");break;
            default: System.out.println("输入有误");break;

        }

    }
}

循环结构

for

for(初始化语句;条件判断语句;条件控制语句){
    循环体语句;
}

for(int i=1;i<=10;i++){
    System.out.println("HelloWorld");
}

while

初始化语名;
while(条件判断语句){
    循环体语句;
    条件控制语句;
}

do…while 循环

初始化语名;
do{
    循环体语句;
    条件控制语句;
}while(条件判断语句);

循环高级

无限循环

for(;;){
            System.out.println("学习");
        }


while(true){
            System.out.println("学习");
        }

do{
            System.out.println("学习");
        }while(true);

跳转控制语句

1 2	contioue; 跳过本次循环，执行下次循环 break; 结束循环

数组

数据格式

格式一：
    数据类型 [] 数据名
    int [] array
    
格式二：
    数据类型 数据名[]
    int array[]
    
    
    // 静态初始化
    完整格式：数据类型[]数组名=new 数据类型[]{元素1,元素2,元素3...};
	int[] array = new int[]{11,22,33};

	简化格式：数据类型[]数组名={元素1,元素2,元素3...};
	int[] arry={11,22,33};

数组元素访问

格式：
    数组名[索引]          //索引从0开始
    int[] arr={1,2,3,4,5};
    int number = arr[0];   // 1

数组的遍历

int[] arr={11,22,33,44};
       for (int i = 0; i <arr.length ; i++) {
       System.out.println(arr[i]);
       }

数组的动态初始化

格式：
    数据类型[] 数组名=new 数据类型[数组长度];
	int[] arr = new int[3];


//数组默认初始化值的规律
//整数类型：默认初始化值0
//小数类型：默认初始化值0.0
//字符类型：默认初始化值 '/u0000' 空格
//布尔类型：默认初始化值 flase
//引用数据类型：默认初始化值 null

方法

方法是程序中最小的执行单元
重复的代码、具有独立功能的代码打一个包，需要用时调用包即可
类似于c语言的函数调用

方法定义

格式：
    public static void 方法名() {
 	方法体(就是打包起来的代码);
}

范例：
    public static void playGame() {
 	七个打印语句;
}


-------------------------------------------------------------
package day4;
public class day4 {
    public static void main(String[] args) {
       //调用方法
        playGame();
        
    }
    //定义一个方法
    public static void playGame(){
        System.out.println("选人物");
        System.out.println("准备开局");
        System.out.println("对线");
        System.out.println("崩盘");
        System.out.println("骂队友");
        System.out.println("送人头");
        System.out.println("GG") ;

    }

}

带参数定义

格式：
    public static void 方法名(数据类型 变量名...) {
 	方法体(就是打包起来的代码);
}

范例：
    public static void sum(int num1 , int num2) {
 	int summ = num1+num2;
    System.out.println(result);
}



------------------------------------------------------
package day4;
import javax.print.DocFlavor;
import java.util.Random;
import java.util.Scanner;
public class day4 {
    public static void main(String[] args) {

       //调用方法    实参
       playGame(10,20);

    }
    //定义一个方法                  形参
    public static void playGame(int a,int b){
       int sum=a+b;
       System.out.println(sum);

    }

}

带返回值方法的定义和调用

格式：
    public static 返回值类型 方法名(参数){
    方法体;
    return 返回值;
}

范例:
	public static int getSum(int a,int b){
        int c =a+b;
        return c;
    }


/*
 返回值类型是 void 时 没有返回值 return
*/

方法的重载

同一个类中，方法名相同，参数不同的方法
java虚拟机会通过参数的不同来区分同名的方法,
    
   public class day4 {  //同一个类
       
       sum(10,20);      //1.
       sum(10,20,30);	//2.
       
       public static int sum(int a,int b){      //1.方法名相同
           return a+b;
   } 
       public static int sum(int a,int b,int c){ //2.方法名相同
           return a+b+c;
   } 
       
}

小练习

//数据中找出最大值
    
package day4;
public class day4 {
    public static void main(String[] args) {
        int[] arr={1,2,6,0,4,8,3};
       //调用方法    				实参
        System.out.println(playGame(arr));

    }
    //定义一个方法                  形参
    public static int playGame(int[] arr){
        int max=arr[0];
      for(int i=1;i<arr.length;i++)
      {
          if(arr[i]>max)
              max=arr[i];
      }
      return max;

    }

}


//拷贝数组

package day4;
public class day4 {
    public static void main(String[] args) {
        int[] arr={1,2,6,0,4,8,3,10,5};

       //调用方法 (用数组接收数组)      实参
        int[] copyarr = playGame(arr,3,7);

        for(int i =0;i<copyarr.length;i++)
            System.out.println(copyarr[i]);


    }
    //         返回也需是数组类型    数组  复制数组的起始位 / 终止位
    public static int[] playGame(int[] arr,int from , int to){
       int[] newArr = new int[to-from];
       int n=0;
      for(int i=from;i<to;i++)
      {
          newArr[n++]=arr[i];

      }
      return newArr;

    }

}

方法的值传递

//形参的改变，不影响实际参数的值
//形参引用数据类型时（数组），传递的地址值，形参的改变，影响实际参数的值
package day4;
public class day4 {
    public static void main(String[] args) {
        int number=100;
        //调用方法    实参

        System.out.println(number);  //100
        playGame(number);
        System.out.println(number);	 //100

    }
    //定义一个方法                  形参
    public static void playGame(int number){
        number = 200;


    }

}

前面的综合练习

卖飞机票

package day4;

import java.util.Scanner;

public class day4 {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入机票的原价");
        int ticket = sc.nextInt();
        System.out.println("请输入当前的月份");
        int month = sc.nextInt();
        System.out.println("请输入当前的购买的舱位 0 头等舱 1 经济舱" );
        int seat = sc.nextInt();

        jiaog(ticket,month,seat);

    }

    public static void jiaog(int ticket, int month , int seat)
    {
        if(month >= 5 && month<=10){

            if(seat==0)
            {
                System.out.println(ticket*0.9);
            }
            else
                System.out.println(ticket*0.85);

        }else if((month>=1 && month<=4) || (month>=11 && month<=12)) {

            if(seat==0)
            {
                System.out.println(ticket*0.7);
            }
            else
                System.out.println(ticket*0.65);

        }else{
            System.out.println("输入的月份是一个非法数据");
        }
    }

}

找质数

package day4;
import java.util.Scanner;
public class day4 {
    public static void main(String[] args) {
        int count=0;
        for(int i=101;i<201;i++){

            if(jiaog(i))
            {
                count++;
                System.out.println(i);
            }
        }
        System.out.println("个数：" + count);
    }

    public static boolean jiaog(int a)
    {
       for(int i=2;i<a/2;i++)
       {
           if(a%i==0)
            return false;
       }
       return true;

    }

}

验证码

package day4;
import java.util.Random;
public class day4 {
    public static void main(String[] args) {

        //分析：
        //1.大写字母和小写字母放在一个数组中
        //再用随机数先数组中的数
        char[] arr= new char[52];
        for(int i=0;i<arr.length;i++)
        {
            if(i<=25)
                arr[i]=(char)(97+i);
            else{
                arr[i]=(char)(65+i-26);
            }
        }
        //字符串类型变量，记录最终的结果
        String result="";

        //随机抽取四次字符
        Random r=new Random();
        for(int a=0;a<4;a++)
        {
            result+=arr[r.nextInt(arr.length)];
        }

        //随机抽取1次数字
        result+=r.nextInt(10);

        //输出
        System.out.println(result);
    }
}

package day4;
import java.lang.reflect.Array;
import java.util.Random;
import java.util.Scanner;

public class day4 {
    public static void main(String[] args) {

        //分析：
        Scanner sc=new Scanner(System.in);
        int[] arr= new int[6];
        int sum=0;
        System.out.println("请输入6名评委打分：");
        for(int i =0;i<arr.length;i++){
            arr[i]=sc.nextInt();
            sum+=arr[i];
        }
        int max=arr[0],min=arr[0];
        for(int a=1;a<arr.length;a++)
        {
            if(arr[a]>max)
                max=arr[a];
            if(min>arr[a])
                min=arr[a];
        }

        double average= (double)(sum-max-min)/4;
        System.out.println(average);
    }


}

数字加密

package day4;
import java.lang.reflect.Array;
import java.util.Random;
import java.util.Scanner;

public class day4 {
    public static void main(String[] args) {

        //分析：
        Scanner sc=new Scanner(System.in);
        int cout=0;
        int number=sc.nextInt();
        int num=number;
        System.out.println("原数字："+  num);
        //看看输入的数是个几位数
        while(num!=0)
        {
        num/=10;
        cout++;
        }

        int[] arr=new int[cout];
        int i=0;
        while(number!=0)
        {
            arr[i++]=((number%10)+5)%10;
            number/=10;
        }
        String name="";
        for(int b=0;b<arr.length;b++)
        {
           name+=arr[b];
        }
        System.out.println("原数字："+ name);
    }


}

抢红包

package day4;
import java.lang.reflect.Array;
import java.util.Random;
import java.util.Scanner;

public class day4 {
    public static void main(String[] args) {

        //分析：
        Random r=new Random();
        int[] arr={2,588,888,1000,10000};
        int[] arr1=new int[5];
        int number;
        int count=0;
        boolean m=false;
        while(count!=5) {
            number = r.nextInt(5);
            for (int i = 0; i < 5; i++) {

                if (arr[number] == arr1[i])
                { m=false; break;}
                else
                 m=true;
            }
            if(m)
            arr1[count++] = arr[number];
        }
        for(int b=0;b<5;b++)
        {
            System.out.println(arr1[b] + "元的奖金被抽出");
        }
    }


}

双色球系统

package day4;
import java.lang.reflect.Array;
import java.util.Random;
import java.util.Scanner;

public class day4 {
    public static void main(String[] args) {

        int[] arr= new int[7];
        Scanner sc=new Scanner(System.in);
        //输入
        for(int i=0;i<7;i++)
        {
            arr[i]=sc.nextInt();
        }

        //随机双色球中奖：
//        Random r = new Random();
//        String name="";
//        int[] arr1 = new int[7];
//        for(int i=0;i<6;i++)
//        {
//            arr1[i]=r.nextInt(33)+1;
//            name+=arr1[i];
//            name+=" ";
//        }
//        arr1[6]=r.nextInt(16)+1;
//        name+=arr1[6];

        //固定中奖答案
        String name="";
        int[] arr1={28,25,9,4,15,30,10};
        for(int i=0;i<7;i++)
        {
            name+=arr1[i];
            name+=" ";
        }

        System.out.println("中将号码："+name);

        int cout=0;
        for(int i=0;i<6;i++)
        {  for(int b=0;b<6;b++){
            if(arr[b]==arr1[i])
                cout++;
        }

        }

        if(arr[6]==arr1[6])
        {
            switch (cout){
                case 0:
                case 1:
                case 2: System.out.println("六等奖：5元");break;
                case 3: System.out.println("五等奖：10元");break;
                case 4: System.out.println("四等奖：200元");break;
                case 5: System.out.println("三等奖：3000");break;
                case 6: System.out.println("一等奖：最高1000万");break;

        }
        }
        else if(cout==4)
        {
            System.out.println("五等奖：10元");
        }
        else if(cout==5)
        {
            System.out.println("四等奖：200元");
        }
        else if(cout==6)
        {
            System.out.println("一等奖：最高500万");
        }

    }
}

面向对象

面向：拿、找
对象：能干活的东西
面向对象编程：拿东西过来做对应的事情

1
2
3

学习获取已有对象并使用（比如，用到了随机数）

学习如何自己设计对象并使用

类和对象

如何定义类

 public class 类名{    // 类名要与文件名一致
     1.成员变量（代表属性，一般是名词）
     2.成员方法（代表行为，一般是动词）
     3.构造器（后面学习）
     4.代码块（后面学习）
     5.内部类（后面学习）
 }

--------------------------------------------------

public class Phone {   //定义类（手机）  类名要与文件名一致

    //属性
    String brand;   //手机的品牌
    double price;   //手机的价格

    //行为：
    public void call(){
        System.out.println("手机在打电话");
    }

    public void playGame(){
        System.out.println("手机在玩游戏");
    }



}

如何得到类的对象

类名 对象名 = new 类名();

//创建手机的对象1
Phone p = new Phone();

如何使用对象

访问属性：对象名.成员变量
访问行为：对象名.方法名(...)
    
    
//创建手机的对象1
Phone p = new Phone();

//叫做给手机1赋值
p.brand = "小米";
p.price = 1999.98;

//获取手机对象中的值
System.out.println(p.brand);
System.out.println(p.price);

//调用手机中的方法即可
p.call();
p.playGame();

day4

package day4;
public class day4 {
    public static void main(String[] args) {

      //创建手机的对象1
      Phone p = new Phone();

      //叫做给手机1赋值
      p.brand = "小米";
      p.price = 1999.98;

      //获取手机对象中的值
      System.out.println(p.brand);
      System.out.println(p.price);

      //调用手机中的方法即可
      p.call();
      p.playGame();

/*--------------------------------------------------------------------------------------*/

      //创建手机的对象2
      Phone p2 = new Phone();

      //叫做给手机2赋值
      p2.brand = "苹果";
      p2.price = 8999 ;

      p2.call();
      p2.playGame();
    }
}

Phone

package day4;

public class Phone {   //定义类（手机）

    //属性
    String brand;   //手机的品牌
    double price;   //手机的价格

    //行为：
    public void call(){
        System.out.println("手机在打电话");
    }

    public void playGame(){
        System.out.println("手机在玩游戏");
    }
}

封装

原则：对象代表什么，就得封装对应的数据，并提供数据对应的行为

1
2
3

// 对象代表什么，就得封装对应的数据， 并提供数据对应的行为

要求：人画圆，请针对这个需要进行面向对象设计

需要 ： 人关门，请针对这个需要进行面向对象设计
    
    开门关门的操作方法，应该放 人 类 还是 门 类？
    
    
    public class Door{
        boolean flag = true;
        
        public void open(){ 
            //开门，修改门的状态
        }
        public void close(){
            //关门，修改门的状态
        }
    }

私有关键字 — private

会更安全

GirlFriend

package day4;

public class GirlFriend {

    //属性
    private String name;
    int age;
    private String gender;

    //针对每一个私有化的成员变量，都要提供get和set方法
    //set方法：给成员变量赋值
    //get方法：对外提供成员变量的值

    //作用：给成员变量name进行赋值的
    public void setName(String n){
        name = n;
    }

    //作用：对外提供name属性
    public String getName(){
        return name;
    }

    //age
    //setAge:给成员变量age进行赋值的
    //getAge:对外提供成员变量get的值
    public void setAge(int a){
        if(a>=18 && a<=50){
            age=a;
        }else{
            System.out.println("输入有误！");
        }
    }

    public int getAge(){
        return age;
    }

    //gender
    public void setGender(String g){
        gender=g;
    }

    public String getGender(){
        return gender;
    }

    //吃
    public void eat(){
        System.out.println("女朋友在吃饭");
    }
    //睡觉
    public void sleep(){
        System.out.println("女朋友在睡觉");
    }

}

day4

package day4;
public class day4 {
    public static void main(String[] args) {

      //创建女朋友的对象1
      GirlFriend p = new GirlFriend();

      //叫做给女朋友1赋值
      p.setName("小星星");
      p.setAge(20);
      p.setGender("大胸妹");

      //获取女朋友1中的值
      System.out.println(p.getName());
      System.out.println(p.getAge());
      System.out.println(p.getGender());

      p.eat();
      p.sleep();

    }
}

this 关键字

成员变量和局部变量


public class GirlFriend {
    private int age;		//成员变量
         int age=10;			//局部变量
        System.out.println(age);  // 10  就近原则  (局部变量)
    }   
}

------------------------------------------------------------------

public class GirlFriend {
    private int age;		//成员变量
    public void method(){
        int age=10;			//局部变量
        System.out.println(this.age);  // null (成员变量)
    }   
}

构造方法

// 作用：在创建对象的时候给成员变量进行初始化的。
// 空参构造 与 带参构造 只能二选一
// 如果没有构造，虚拟机会默认自己加一个空参构造方法
结构：
public class Student{
    修饰符 类名(参数){
        方法体;
    }
}
-------------------------------------------------------------------

Student.java
    
public class Student{
    private String name;
    private int age;
    
    public Student(){
        ...   //空叁构造     
    }
    public student( String name , int age ){
        ...   //带叁构造
    }
}

day4.java

public class StudentTest{
    public static void main(String[] args){
        //创建对象
        //调用的空参构造
        Student s = new Student();
        
        //调用有参构造
        System s = new Student("zhangsan",23);
        System.out.println(s.getName());
        System.out.println(s.getAge());
        
    }
}

标准的 javabean 类

快捷键一键生成标准的 javabean 类

基本数据类型和引用数据类型

基本数据类型					引用数据类型
 
 整数类型				  除了左边的其他所有类型
 浮点数类型				     对象、数组等等
 布尔类型
 字符类型

面向对象综合练习

文字版格斗游戏

第一版

day4.java

package day4;

import java.security.PublicKey;

public class day4 {
    public static void main(String[] args) {

      //创建二个角色，
      role role1=new role("乔峰",100);
      role role2=new role("鸠魔智",100);

      //开始格斗 回合制格斗
        while (true){
            //角色1开始攻击角色2
            role1.attack(role2);
            //判断角色2的剩余血量
            if(role2.getBlood()==0){
                System.out.println(role1.getName()+"KO了"+role2.getName());
                break;
            }

            //角色2开始攻击角色1
            role2.attack(role1);
            //判断角色2的剩余血量
            if(role1.getBlood()==0){
                System.out.println(role2.getName()+"KO了"+role1.getName());
                break;
            }
        }

    }
}

role.java

package day4;

import java.util.Random;

public class role {
    private String name;
    private int blood;


    public role() {
    }

    public role(String name, int blood) {
        this.name = name;
        this.blood = blood;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return blood
     */
    public int getBlood() {
        return blood;
    }

    /**
     * 设置
     * @param blood
     */
    public void setBlood(int blood) {
        this.blood = blood;
    }

    //定义一个方法用于攻击别人
    public void attack(role role){
        //计算造成的造成1~20
        Random r= new Random();
        int hurt = r.nextInt(20)+1;

        //剩余血量
        int remainBoold = role.getBlood() - hurt;
        //对剩余血量做一个验证，不能使血量为负数
        remainBoold = remainBoold < 0 ? 0 : remainBoold;
        //修改一下挨揍的人的血量
        role.setBlood(remainBoold);

        System.out.println(this.getName()+"起拳头，打了"+role.getName()+"一下，"+
                "造成了"+ hurt +"点伤害，"+ role.getName() +"还剩下了"+remainBoold+"点血");
    }
}

第二版

day4.java

package day4;

import java.security.PublicKey;

public class day4 {
    public static void main(String[] args) {

      //创建二个角色，
      role role1=new role("乔峰",100,'男');
      role role2=new role("鸠魔智",100,'男');

      //展示一下角色信息
      role1.showRoleInfo();
      role2.showRoleInfo();

      //开始格斗 回合制格斗
        while (true){
            //角色1开始攻击角色2
            role1.attack(role2);
            //判断角色2的剩余血量
            if(role2.getBlood()==0){
                System.out.println(role1.getName()+"KO了"+role2.getName());
                break;
            }

            //角色2开始攻击角色1
            role2.attack(role1);
            //判断角色2的剩余血量
            if(role1.getBlood()==0){
                System.out.println(role2.getName()+"KO了"+role1.getName());
                break;
            }
        }



    }
}

role.java

package day4;

import java.util.Random;

public class role {
    private String name;
    private int blood;
    private char gender;   //性别
    private String face;   //长相是随机的
    String[] boyfaces= {"风流俊雅","气宇轩昂","相貌英俊","五官端正","相貌平平","一塌糊涂","面目狰狞"};
    String[] girlfaces ={"美奂绝伦","沉鱼落雁","婷婷玉立","身材娇好","相貌平平","相貌简陋","惨不忍睹"};

    //attack攻击描述:
    String[] attacks_desc={
        "%s使出了一招[背心钉]，转到对方的身后，一掌向%s背心的灵台穴拍去。",
        "%s使出了一招[游空探爪]，飞起身形自半空中变掌为抓锁向%S。",
        "%s大喝- -声，身形下伏, -招[劈雷坠地] ,捶向%s双腿。",
        "%s运气于掌,一瞬间掌心变得血红, -式[掌心雷]，推向%S。",
        "%s阴手翻起阳手跟进，一招[没遮拦]，结结实实的捶向%S。",
        "%s上步抢身，招中套招，一~招 [劈挂连环]，连环攻向%S。"
    };


    //injured受伤描述:
    String[] injureds_desc={
        "结果%s退了半步，毫发无损",
        "结果给%s造成- -处瘀伤",
        "结果一 击命中，%s痛得弯下腰",
        "结果%s痛苦地闷哼了-声，显然受了点内伤",
        "结果%s摇摇晃晃，- -跤摔倒在地",
        "结果%s脸色- -下变得惨白，连退了好几步",
        "结果「轰」的一-声,%s口中鲜血狂喷而出",
        "结果%s一声惨叫，像滩软泥般塌了下去"
    };




    public role() {
    }

    public role(String name, int blood , char gender) {
        this.name = name;
        this.blood = blood;
        this.gender = gender;
        //随机长相
        setFace(gender);
    }

    /**
     * 获取
     * @return gender
     */
    public char getGender() {
        return gender;
    }

    /**
     * 设置
     * @param gender
     */
    public void setGender(char gender) {
        this.gender = gender;
    }

    /**
     * 获取
     * @return face
     */
    public String getFace() {
        return face;
    }

    /**
     * 设置
     * @param face
     */
    public void setFace(char gender) {
        Random r=new Random();

        //长相是随机的 而且男女随机的也不同
        if(gender == '男'){
            //从boyfaces里面随机长相
            int index=r.nextInt(boyfaces.length);
            this.face=boyfaces[index];
        }else if(gender == '女'){
            //从girlfaces里面随机长相
            int index=r.nextInt(girlfaces.length);
            this.face=girlfaces[index];
        }else{
            this.face = "面目狰狞";
        }

    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return blood
     */
    public int getBlood() {
        return blood;
    }

    /**
     * 设置
     * @param blood
     */
    public void setBlood(int blood) {
        this.blood = blood;
    }

    //定义一个方法用于攻击别人
    public void attack(role role){

        Random r= new Random();
        int index=r.nextInt(attacks_desc.length);
        String KungFu = attacks_desc[index];


        //输出一个攻击的效果
        System.out.printf(KungFu,this.getName(),role.getName());
        System.out.println();


        //计算造成的造成1~20
        int hurt = r.nextInt(20)+1;

        //剩余血量
        int remainBoold = role.getBlood() - hurt;
        //对剩余血量做一个验证，不能使血量为负数
        remainBoold = remainBoold < 0 ? 0 : remainBoold;
        //修改一下挨揍的人的血量
        role.setBlood(remainBoold);

        //受伤的描述
        //血量>90   0索引的描述
        //80~90     1索引的描述
        //70~80     2索引的描述
        //60~70     3索引的描述
        //40~60     4索引的描述
        //20~40     5索引的描述
        //10~20     6索引的描述
        //小10的     7索引的描述
        if(remainBoold > 90){
            System.out.printf(injureds_desc[0],role.getName());
        }else if(remainBoold > 80){
            System.out.printf(injureds_desc[1],role.getName());
        }else if(remainBoold > 70){
            System.out.printf(injureds_desc[2],role.getName());
        }else if(remainBoold > 60){
            System.out.printf(injureds_desc[3],role.getName());
        }else if(remainBoold > 40){
            System.out.printf(injureds_desc[4],role.getName());
        }else if(remainBoold > 20){
            System.out.printf(injureds_desc[5],role.getName());
        }else if(remainBoold > 10){
            System.out.printf(injureds_desc[6],role.getName());
        }else{
            System.out.printf(injureds_desc[7],role.getName());
        }
        System.out.println();
//        System.out.println(this.getName()+"起拳头，打了"+role.getName()+"一下，"+
//                "造成了"+ hurt +"点伤害，"+ role.getName() +"还剩下了"+remainBoold+"点血");
    }

    public void showRoleInfo(){
        System.out.println("姓名为："+getName());
        System.out.println("血量为："+getBlood());
        System.out.println("性别为："+getGender());
        System.out.println("长相为："+getFace());
    }
}

对象数组

1

day5.java

package day5;
public class day5 {
    public static  void main(String[] args){
        //创建一个数组对象
        Goods[] arr = new Goods[3];

        //2.创建三个商品对象
        Goods g1 = new Goods("001","华为",5999,100);
        Goods g2 = new Goods("002","保温杯",227,50);
        Goods g3 = new Goods("003","枸杞",12.7,70);

        //3.把商品添加到数组中
        arr[0] = g1;
        arr[1] = g2;
        arr[2] = g3;

        //4.遍写
        for(int i=0;i<arr.length;i++){
            //i 索引 arr[i] 元素
            Goods goods = arr[i];
            System.out.println(goods.getId() + "," + goods.getName() +"," + goods.getPrice() + "," + goods.getCount());
        }
    }
}

Goods.java

package day5;

public class Goods {
        private String id;
        private String name;
        private double price;
        private int count;

    public Goods() {
    }

    public Goods(String id, String name, double price, int count) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.count = count;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }
}

2

day5.java

package day5;

import java.util.Scanner;
import java.util.zip.CheckedOutputStream;

public class day5 {
    public static  void main(String[] args){
        //创建一个数组对象
        car[] arr = new car[3];

        //2.创建汽车对象，数据来自于键盘录入
        Scanner sc= new Scanner(System.in);

        for(int i=0;i<arr.length;i++)
        {
            //创建汽车的对象
            car c=new car();

            //录入品牌
            System.out.println("请输入汽车品牌:");
            String brand = sc.next();
            c.setName(brand);

            //录入价格
            System.out.println("请输入汽车价格:");
            int price = sc.nextInt();
            c.setPrice(price);

            //录入颜色
            System.out.println("请输入汽车颜色:");
            String color = sc.next();
            c.setColor(color);

            //把汽车对象添加到数组中
            arr[i]=c;

        }

        //3.编历数组
        for(int i =0;i<arr.length;i++) {
            car car = arr[i];
            System.out.println(car.getName() + "," + car.getPrice() +"," + car.getColor());

        }
    }
}

Goods.java

package day5;

public class car {
    private String name;
    private int price;
    private String color;

    public car() {
    }

    public car(String name, int price, String color) {
        this.name = name;
        this.price = price;
        this.color = color;
    }

    public String getName() {
        return name;
    }

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

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

3

day5.java

package day5;

import java.util.Scanner;
import java.util.zip.CheckedOutputStream;

public class day5 {
    public static  void main(String[] args){
        //创建一个数组对象
        phone[] arr=new phone[3];

        //2.创建手机对象，数据来自于键盘录入
        Scanner sc= new Scanner(System.in);

        for(int i=0;i<arr.length;i++)
        {
            //创建手机的对象
            phone c=new phone();

            //录入品牌
            System.out.println("请输入手机品牌:");
            String brand = sc.next();
            c.setName(brand);

            //录入价格
            System.out.println("请输入手机价格:");
            int price = sc.nextInt();
            c.setPrice(price);

            //录入颜色
            System.out.println("请输入手机颜色:");
            String color = sc.next();
            c.setColor(color);

            //把汽车对象添加到数组中
            arr[i]=c;

        }

        //3.编历数组
        double sum=0;
        for(int i =0;i<arr.length;i++) {
            phone phone = arr[i];
            sum+=phone.getPrice();

        }
        System.out.println("手机的平均价格："+(sum/arr.length));
    }
}

phone.java

package day5;

public class phone {
    private String name;
    private double price;
    private String color;

    public phone() {
    }

    public phone(String name,double price,String color) {
        this.name=name;
        this.price=price;
        this.color=color;
    }

    public  String getName() {
        return name;
    }

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

    public  double getPrice() {
        return price;
    }

    public  void setPrice(double price) {
        this.price = price;
    }

    public  String getColor() {
        return color;
    }

    public  void setColor(String color) {
        this.color = color;
    }


}

4

day5.java

package day5;

import java.util.Scanner;
import java.util.zip.CheckedOutputStream;

public class day5 {
    public static  void main(String[] args){
        //创建一个数组对象
       GirlFriend[] arr=new GirlFriend[4];

       //创建女朋友的对象
       GirlFriend girl1=new GirlFriend("丽丽",18,"女" ,"跳舞");
       GirlFriend girl2=new GirlFriend("雯雯",20,"女" ,"唱歌");
       GirlFriend girl3=new GirlFriend("晓晓",18,"女" ,"瑜伽");
       GirlFriend girl4=new GirlFriend("红红",22,"女" ,"看书");

       //把女朋友们添加到数组当中
       arr[0]=girl1;
       arr[1]=girl2;
       arr[2]=girl3;
       arr[3]=girl4;

        //计算出四女朋友的平均年龄
        double sum=0;
       for( int i=0;i<arr.length;i++)
       {
           sum+=(arr[i].getAge());
       }
       double average=sum/arr.length;
        System.out.println("四女朋友的平均年龄"+average);

        //统计年龄比平均值低的女朋友有几个？并把她们的所有信息打印出来
        int count=0;
        for( int i=0;i<arr.length;i++)
        {
          GirlFriend g=arr[i];
          if((g.getAge())<average)
          {
              count++;
              System.out.println("姓名："+g.getName()+"|"+"年龄："+g.getName()+"|"+"性别："+g.getSex()+"|"+"爱好："+g.getHobby());
          }
        }
        System.out.println("年龄比平均值低的女朋友有"+count+"个");

    }
}

GirlFriend.java

package day5;

public class GirlFriend {
    private String name;
    private  int age;
    private String sex;
    private String hobby;

    public GirlFriend() {
    }

    public GirlFriend(String name, int age, String sex, String hobby) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.hobby = hobby;
    }

    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 String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getHobby() {
        return hobby;
    }

    public void setHobby(String hobby) {
        this.hobby = hobby;
    }
}

5

day5

package day5;

import java.util.Scanner;
import java.util.zip.CheckedOutputStream;

public class day5 {
    public static  void main(String[] args){
        //创建一个数组对象
        student[] arr= new student[3];


        //创建学生对象并添加到数组当中
        student stu1=new student(1,"小明",18);
        student stu2=new student(2,"小红",20);
        student stu3=new student(3,"小金",22);

        arr[0]=stu1;arr[1]=stu2;arr[2]=stu3;

        //要求1:再次添加一个学生对象,并在添加的时候进行学号的唯一性判断 。

        //添加一个学生对象
        student stu4=new student(4,"小蓝",19);

        //学号的唯一性判断
        boolean flag=id1(arr,stu4.getId());
        if(flag){
            System.out.println("已经存在");
        }else{
            //id不存在--------就可以把学生对象添加进数组
            //1.数组已经存满了-----只能创建一个新的数组，新数组的长度=老数组+1;
            //2.数级示存满----直接添加存入即可
            int cou=count(arr);
            if(cou==arr.length){
                //已经存满
                //创建一个新数组=老数组的长度+1
                //然后把老数组的元素全部拷贝到新数组
                student[] newArr = creatNewArr(arr);
                newArr[cou]=stu4;
                //要求2.添加完毕之后，遍历所有学生信息
                printArr(newArr);
            }else{
                //没有存满
                arr[cou]=stu4;
                //要求2.添加完毕之后，遍历所有学生信息
                printArr(arr);
            }

        }

        //要求3 通过id删除学生信息
        //如果存在，则删除，如果不存在，则提示删除失败

        //找id在数组中的对应的索引
        int index=find(arr,2);
        if(index>=0){
            //存在，删除
            arr[index] = null;
            //要求4 遍历
            printArr(arr);
        }else{
            System.out.println("id不存在");
        }

        //要求5 查询数组id为 2 的学生，存在，则将他的年龄+1岁
        //找id在数组中的对应的索引
        int ind=find(arr,1);

        if(ind>=0){
            //存在，年龄+1
             student ar=arr[ind];
             int age1=ar.getAge();
             ar.setAge(age1+1);
             //遍历查看年龄是否+1
             printArr(arr);
        }else{
            System.out.println("id不存在");
        }

    }

    //找id在数组中的对应的索引
    public static int find(student[] arr,int a){
        for (int i = 0; i < arr.length; i++) {
            student s=arr[i];
            if(s.getId()==a){
                return i;
            }
        }
        return -1;
    }



    //遍历所有学生的信息
    public static void printArr(student[] arr){
        for (int i = 0; i < arr.length; i++) {
            student s=arr[i];
            if(s==null) continue;
            System.out.println("学号："+s.getId()+"姓名："+s.getName()+"年龄："+s.getAge());
        }
    }

    //创建新数组并拷贝
    public static student[] creatNewArr(student[] arr){
        student[] newArr=new student[arr.length+1];
        for (int i = 0; i < arr.length; i++) {
            newArr[i]=arr[i];
        }
        return newArr;
    }

    //定义一个方法判断数组中已经存在了几个元素----判断数组是否存满了

    public static int count(student[] arr){
        int c=0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]!=null){
                c++;
            }
        }
        return c;
    }



    //  学号唯一性
    public static boolean id1(student[] arr,int id){
        for(int i=0;i<arr.length;i++){
            student stu=arr[i];
            if(stu!=null) {
                int sid = arr[i].getId();
                if (sid == id) {
                    return true;
                }
            }
        }
        return false;
    }
}

student.java

package day5;

public class student {
    private int id;
    private String name;
    private int age;


    public student() {
    }

    public student(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public int getId() {
        return id;
    }

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

    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;
    }
}

字符串

API

API：
目前是JDK中提供的各种功能的java类
这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可
    
API帮助文档：帮助开发人员更好的使用API和查询API的一个工具

API帮助文档

使用步骤：

显示—索引—输入你要查找的关键字—显示

String

字符串的比较

== 号比较的是什么？

基本数据类型（int）	引用数据类型(String)
基本数据类型比较的是数据值	引用数据类型比较的是地址值

package index;

public class index {
    public static void main(String[] args) {
        //直接赋值是串池里面的地址值
       String s1="abc";
       String s2="abc";
       System.out.println(s1==s2); //true

        //new是堆里面的地址值,键盘输入的字符串也是 new
        String s3=new String("abc");
        String s4= "abc";
        System.out.println(s1==s2);  //false


    }
}

字符串内容比较

equals 方法	equalsIgnoreCase方法
完全一样结果才是 true ,否则为 false	忽略大小写的比较

package index;

import javax.lang.model.element.NestingKind;

public class index {
    public static void main(String[] args) {
        //创建两个字符串对象
        String s1=new String("abc");
        String s2 = "Abc";

     //比较字符串对象中的内容是否相等
        boolean result1 = s1.equals(s2);
        System.out.println(result1);

        //比较字符串对象中的内容是否相等,忽略大小写
        boolean result2 = s1.equalsIgnoreCase(s2);
        System.out.println(result2);

    }
}

综合练习

用户登录

package index;

import javax.lang.model.element.NestingKind;
import java.util.Scanner;

public class index {
    public static void main(String[] args) {
        Scanner sc= new Scanner(System.in);

        String rightUsername="fhqicfh";
        String rightPassword="123456";

        for(int i=0;i<3;i++){


            System.out.println("请输入账号：");
            String username=sc.next();
            boolean name=username.equals(rightUsername);

            System.out.println("请输入密码：");
            String password=sc.next();
            boolean pass=password.equals(rightPassword);
            if(name&&pass){
                System.out.println("登录成功");
                break;
            }else{
                System.out.println("账号或密码有误！\n");
            }


        }

    }
}

遍历字符串

字符串对象.charAt(int index)	字符串对象.length()
遍历字符串	字符串的长度


package index;

import javax.lang.model.element.NestingKind;
import java.util.Scanner;

public class index {
    public static void main(String[] args) {
        // 1.键盘录入一个字符串
        Scanner sc= new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str=sc.next();

        // 2.进行遍历
        for(int i = 0;i<str.length();i++) {
            //i 依次表示字符串的每一个索引
            char c = str.charAt(i);
            System.out.println(c);

        }
    }
}

统计字符次数

package index;

import javax.lang.model.element.NestingKind;
import java.util.Scanner;

public class index {
    public static void main(String[] args) {
        // 1.键盘录入一个字符串
        Scanner sc= new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str=sc.next();


        int countCharD=0,countCharX=0,countNumber=0;
        // 2.进行遍历
        for(int i = 0;i<str.length();i++) {
            //i 依次表示字符串的每一个索引
            char c=str.charAt(i);
           if(c>='A'&&c<='Z'){
               countCharD++;
           }else if(c>='a'&&c<='z'){
               countCharX++;
           }else if(c>='1'&&c<='9'){
               countNumber++;
           }

        }
        System.out.println("大写字母字符"+countCharD);
        System.out.println("小写字母字符"+countCharX);
        System.out.println("数字字符"+countNumber);
    }
}

拼接字符串

package index;

import javax.lang.model.element.NestingKind;
import java.util.Scanner;

public class index {
    public static void main(String[] args) {
       int[] arr={1,2,3,4,5};
        String s= arrString(arr);
        System.out.println(s);
    }


    public static String arrString(int[] arr){
        if(arr==null){
            return "";
        }
        if(arr.length==0){
            return "[]";
        }
        String result="[";
        for (int i = 0; i < arr.length; i++) {
            if(i==arr.length-1)
            {     result+=arr[i];
            }else{
                result+=arr[i]+",";
            }
        }
        result+="]";
        return result;
    }
}

字符串反转

package index;

import javax.lang.model.element.NestingKind;
import java.util.Scanner;

public class index {
    public static void main(String[] args) {
     Scanner sc= new Scanner(System.in);
     System.out.println("请输入字符串：");
     String s=sc.next();
     System.out.println(arrString(s));


    }
    public static String arrString(String arr){
        String s="";
        for(int i=arr.length()-1;i>=0;i--){
            char c=arr.charAt(i);
            s+=c;
        }
        return s;
    }
}

金额转换

package index;

import javax.lang.model.element.NestingKind;
import java.util.Scanner;
import java.util.zip.CheckedOutputStream;

public class index {
    public static void main(String[] args) {
     Scanner sc= new Scanner(System.in);
     System.out.println("请输入金额：");
     int money=sc.nextInt();
     if(money>=0&&money<=9999999){

     }else{
         System.out.println("金额无效！");
     }
     String s="";
     String m;

    while (true){
        int ge=money%10;
        money/=10;

        m=arrString(ge);
        s=m+s;

        if(money==0){
            break;
        }

    }
        int count=7-s.length();
        for(int i =0 ;i< count;i++){
        s="零"+s;
        }

        char[] arr={'佰','拾','万','仟','佰','拾','元'};
        String result="";
        for(int i=0;i<s.length();i++)
        {
           char c = s.charAt(i);
           result = result+ c + arr[i];
        }
        System.out.println(result);

    }
    public static String arrString(int number){

        String[] arr={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};

        return arr[number];
    }
}

手机号屏蔽

字符串.substring(int a,int b)	字符串.substring(int a)
从a截取到b,包括a,包括b	从a截取到尾未

package index;

import javax.lang.model.element.NestingKind;
import java.util.Scanner;
import java.util.zip.CheckedOutputStream;

public class index {
    public static void main(String[] args) {
     //获取一个手机号码
        String phoneNumber="13112349468";
        String s = phoneNumber.substring(0,3);
        String m = phoneNumber.substring(7);
        String result = s + "****" + m;
        System.out.println(result);
    }
}

身份证信息查看

package index;

import javax.lang.model.element.NestingKind;
import java.util.Scanner;
import java.util.zip.CheckedOutputStream;

public class index {
    public static void main(String[] args) {
     //获取一个手机号码
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个身份证：");
        String s=sc.next();

        //出生年、月、日
        String year=s.substring(6,10);
        String month=s.substring(10,12);
        String day=s.substring(12,14);

        System.out.println("出生年月日:"+year+"年"+month+"月"+day+"日");


        //性别
        char sex=s.charAt(16);
        int sexX=(sex-'0');
        if(sexX%2==0){
            System.out.println("性别为:女");
        }
        else{
            System.out.println("性别为:男");
        }


    }
}

敏感词替换

字符串.replace(旧值,新值)
替换只有返回值才是替换之后的结果

package index;

import javax.lang.model.element.NestingKind;
import java.util.Scanner;
import java.util.zip.CheckedOutputStream;

public class index {
    public static void main(String[] args) {
     //说的话
      String spake="你玩的真好啊，别TM的玩了，SB";
      
     //敏感词库
     String[] arr={"TM","SB","TMD","CNM"};

        for (int i = 0; i < arr.length; i++) {
            spake= spake.replace(arr[i],"***");

        }
        System.out.println(spake);


    }
}

StringBuijlder

操作效率更高

综合练习

创建方法

方法名	说明
public StringBuilder()	创建一个空白可变字符串对象，不含有任何内容
public StringBuilder(String str)	根据字符串的内容，来创建可变字符串对象

常用方法

方法名	说明
public StringBuilder append(任意类型)	添加数据，并返回对象本身
public StringBuilder reverse()	反转容器中的内容
public int length()	返回长度（字符出现的个数）
public String toString()	通过toString()就可以实现把 String Builder 转换为 String

package index;

import javax.lang.model.element.NestingKind;
import java.text.DecimalFormat;
import java.util.Random;
import java.util.Scanner;
import java.util.zip.CheckedOutputStream;
import java.util.zip.DeflaterOutputStream;

public class index {
    public static void main(String[] args) {

       //1.创建对象
        StringBuilder sb = new StringBuilder("投币");

        //添加元素
        sb.append(1);
        sb.append(2.3);
        sb.append(true);

        //反转
        sb.reverse();

        //获取长度
        int len=sb.length();
        System.out.println(len);

        //再把StringBuilder变回字符串
        String str= sb.toString();
        System.out.println(str);

        //打印
        //普及：因为StringBuilder是Java已经写好的类
        //java在底层对他做了一些特殊处理。
        //打印对象不是地址而是属性值。
        System.out.println(sb);

        }
    }

对称字符串

package index;
import java.util.Random;
import java.util.Scanner;
public class index {
    public static void main(String[] args) {
        //键盘录入一个字符串
       Scanner sc = new Scanner(System.in);
       String s=sc.next();

       //2.反转键盘录入的字符串
         String m = new StringBuilder().append(s).reverse().toString();
         if(s.equals(m)){
             System.out.println(s+"是对称字符串");
         }
         else{
             System.out.println(s+"是非对称字符串");
         }

        }
    }

拼接字符串

package index;
import java.util.Random;
import java.util.Scanner;
public class index {
    public static void main(String[] args) {
        //int 数组
        int[] arr={1,2,3,4,5};
        System.out.println(printfF(arr));
        }

        public static String printfF(int[] arr){
        StringBuilder sb=new StringBuilder();
        sb.append("[");
            for (int i = 0; i < arr.length; i++) {
                if(i==arr.length-1){
                    sb.append(arr[i]);
                }else{
                    sb.append(arr[i]).append(",");
                }
            }
            sb.append("]");
            return sb.toString();
        }
    }

StringJoiner

提高字符串的操作效率，代码也简洁

方法名	说明
public StringJoiner(间隔符号)	创建一个StringJoiner对象，指定拼接时的间隔符号
public StingJoiner(间隔符号，开始符号，结束符号)	创建一个StringJoiner对象，指定拼接时的间隔符号、开始符号、结束符号

方法名	说明
public StringJoiner add(添加的内容)	添加数据，并返回对象本身
public int length()	返回长度（字符出现的个数）
public String toString()	返回一个字符串（该字符串就是拼接之后的结果）

package index;
import java.util.Random;
import java.util.Scanner;
import java.util.StringJoiner;
public class index {
    public static void main(String[] args) {

        //1.创建一个对象，并指定中间的间隔符号
        StringJoiner sj=new StringJoiner("---");
        StringJoiner js=new StringJoiner(",","[","]");

        //2.添加元素
        sj.add("aaa").add("bbb").add("ccc");
        js.add("aaa").add("bbb").add("ccc");

        //3.打印结果
        System.out.println(sj);  // aaa---bbb---ccc
        System.out.println(js);  // [aaa,bbb,ccc]
        
        int len=js.length();
        System.out.println(len);  // 13 （包括 “[” “]” "," “aaa” , “bbb” ,"ccc"）
        }
    }

综合大练习

转换罗马数字

package index;
import java.util.Random;
import java.util.Scanner;
import java.util.StringJoiner;

public class index {
    public static void main(String[] args) {

       Scanner sc= new Scanner(System.in);
       while(true) {
           System.out.println("请输入一个字符串");
           String s = sc.next();
           boolean flag = checkStr(s);
           if (flag) {
                String ss= PrintfString(s);
               System.out.println(ss);
                break;
           }else{
               System.out.println("当前的字符串不符合规则，请重新输入");
               continue;
           }
       }

       //遍历所有的罗马数字
        }
        public static String PrintfString(String str){
            String s="";
            for(int i=0;i<str.length();i++){
                char a=str.charAt(i);
                int number;
                if(a!='0'){
                number=a-'1';
                s=s+luoMa(number);}
                else{
                    s=s+" ";
                }

            }
            return s;
        }


        //阿拉伯数字转罗马数字
    public static String luoMa(int number){
        String[] arr={"Ⅰ","Ⅱ","Ⅲ","Ⅳ","Ⅵ","Ⅶ","Ⅷ","Ⅸ","Ⅹ",};
        return arr[number];
    }


        public static boolean checkStr(String str){
        //要求1：长度为小于等于9
            if(str.length()>9){
                return false;
            }
         //要求2：只能是数字
            for(int i=0;i<str.length();i++){
                char a=str.charAt(i);
            if(a<'0' || a>'9'){
                return false;
            }
            }
            return true;
        }
    }

调整字符串

package index;
import java.util.Random;
import java.util.Scanner;
import java.util.StringJoiner;

public class index {
    public static void main(String[] args) {

        //1.定义两个字符串
        String strA="abcde";
        String strB="deabc";

        int count=0;
        String s=strA;
        //2.旋转字符串
        while(true)
        {
             s=rotate(s);
             if(s.equals(strB)){
                 System.out.println("true");
                 break;
             }
             count++;
             if(count==(strA.length())){
                 System.out.println("false");
                 break;
             }
        }

        }

        //作用：选择字符串，把左侧的字符移动到右侧去
        //形参：旋转前的字符串
        //返回值：旋转后的字符串
        public static String rotate(String str){
        //套路：
        //如果我们看到要修改字符串的内容
        //可以有两个办法：
        //1.用 subString 进行截取，把左边的字符截取出来拼接到右侧去
        //2.可以把字符串先变成一个字符数组，然后调整字符数组里面数据，最后再把字符数组变成字符串。

        //截取思路
        char a=str.charAt(0);
        String s=str.substring(1);
        return s+a;

        }
    }

package index;
import java.util.Random;
import java.util.Scanner;
import java.util.StringJoiner;

public class index {
    public static void main(String[] args) {

        //1.定义两个字符串
        String strA="abcde";
        String strB="deabc";

        int count=0;
        String s=strA;
        //2.旋转字符串
        while(true)
        {
             s=rotate(s);
             if(s.equals(strB)){
                 System.out.println("true");
                 break;
             }
             count++;
             if(count==(strA.length())){
                 System.out.println("false");
                 break;
             }
        }

        }

        //作用：选择字符串，把左侧的字符移动到右侧去
        //形参：旋转前的字符串
        //返回值：旋转后的字符串
        public static String rotate(String str){
        //套路：
        //如果我们看到要修改字符串的内容
        //可以有两个办法：
        //1.用 subString 进行截取，把左边的字符截取出来拼接到右侧去
        //2.可以把字符串先变成一个字符数组，然后调整字符数组里面数据，最后再把字符数组变成字符串。

        //字符数组
        char[] arr=str.toCharArray();
        char a=arr[0];
            for (int i = 1; i < arr.length; i++) {
                arr[i-1]=arr[i];
            }
            arr[arr.length-1]=a;
            String s=new String(arr);
            return s;

        }
    }

集合 – ArrayList

集合与数组的区别：
    	          集合		            	数组
    长度：		集合的长度可变       		  数组长度固定	 
    
 存储类型：    集合可以存引用数组类型	  可以存基本数据类型
    		 基本数据类型——>包装类	   可以存引用数据类型

集合的基本使用

方法名	说明
增 boolean add(Ee)	添加元素，返回值表示是否添加成功
删 boolean remove(Ee)	删除指定元素，返回值表示是否删除成功
删 E remove(int index,E e)	删除指定索引的元素，返回被删除元素
改 E set(int index,E e)	修改指定索引的元素，返回原来的元素
查 E get(int index)	获取指定索引的元素
int size()	集合的长度，也就是集合中元素的个数

package index;
import java.util.ArrayList;
public class index {
    public static void main(String[] args) {
        //此时我们创建的是ArrayList的对象，而ArrayList是java已经写好的一个类
        //这个类在底层做了一些处理
        //打印对象不是地址值，而是集合中存储数据内容
        //在展示的时候会拿[]把所有的数据进行包裹
        ArrayList<String> list = new ArrayList<>();

        // 2.添加元素
        boolean result=list.add("aaa");
        System.out.println(result);   //true  添加成功

        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        //3.删除元素
        boolean result1 = list.remove("aaa");
        System.out.println(result1); //true  删除成功

        String str=list.remove(0);   // 下标删除
        System.out.println(str);          // 输出删除的内容，证明删除成功

        //修改元素
        String result3=list.set(1,"ddd"); //将下标1的内容修改为 “ddd”
        System.out.println(result3);    //输出被修改的内容，证明修改成功

        //查询元素
        String s = list.get(0);        //查询下标为0的内容
        System.out.println(s);

        System.out.println(list);





    }
}

练习

字符串集合的遍历

package index;
import java.util.ArrayList;
public class index {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> list = new ArrayList<>();

        //添加元素
        list.add("aaaaaaaa");
        list.add("bbbbbbbb");
        list.add("cccccccc");
        list.add("dddddddd");

        //遍历
        System.out.print("[");
        for (int i = 0; i < list.size(); i++) {
            if(i==list.size()-1){
                System.out.print(list.get(i));
            }
            else {
                System.out.print(list.get(i) + ",");
            }
        }
        System.out.println("]");





    }
}

基本数据类型对应的包装类

Int类型集合的遍历

index.java

package index;
import java.util.ArrayList;
public class index {
    public static void main(String[] args) {
        //创建集合   不能写Int类型，要写Int类型对应的包装类
        ArrayList<Integer> list = new ArrayList<>();

        //添加元素
        //jdk5以后 int Integer 之间是可以互相转化的
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

        //遍历集合
        System.out.print("[");
        for (int i = 0; i < list.size(); i++) {
            if(i==list.size()-1){
                System.out.print(list.get(i));
            }
            else {
                System.out.print(list.get(i) + ",");
            }
        }
        System.out.println("]");

    }
}

Student.java

package index;

public class Student {

    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = 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;
    }
}

添加学生对象并遍历

package index;
import java.sql.Struct;
import java.util.ArrayList;
public class index {
    public static void main(String[] args) {
        //创建集合   不能写Int类型，要写Int类型对应的包装类
        ArrayList<Student> list = new ArrayList<>();
		
        
        //2.键盘录入学生的信息并添加到集合当中
        Student s1=new Student("张三", 18);
        Student s2=new Student("五六", 20);
        Student s3=new Student("七八", 25);

        //添加元素
        //jdk5以后 int Integer 之间是可以互相转化的
        list.add(s1);
        list.add(s2);
        list.add(s3);

        //遍历集合

        for (int i = 0; i < list.size(); i++) {
            Student stu=list.get(i);
            System.out.println(stu.getName()+","+stu.getAge());

        }

    }
}

index.java

package index;
import java.sql.Struct;
import java.util.ArrayList;
import java.util.Scanner;

public class index {
    public static void main(String[] args) {
        //创建集合   不能写Int类型，要写Int类型对应的包装类
        ArrayList<Student> list = new ArrayList<>();

        //键盘录入学生的信息并添加到集合当中
        Scanner sc = new Scanner(System.in);

        for (int i = 0; i < 3; i++) {
            Student s= new Student();
            System.out.println("请输入学生的姓名：");
            String s1=sc.next();
            System.out.println("请输入学生的年龄：");
            int s2=sc.nextInt();

            //把name和age赋值给学生对象
            s.setName(s1); s.setAge(s2);

            //把学生对象添加到集合当中
            list.add(s);
        }

        //遍历集合

        for (int i = 0; i < list.size(); i++) {
            Student stu=list.get(i);
            System.out.println(stu.getName()+","+stu.getAge());

        }

    }
}

Student.java

package index;

public class Student {

    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = 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;
    }
}

添加用户对象并判断是否存在

index.java

package day6;
import javax.lang.model.element.NestingKind;
import java.sql.Struct;
import java.util.ArrayList;
import java.util.Scanner;

public class index {
    public static void main(String[] args) {
        //创建集合   不能写Int类型，要写Int类型对应的包装类
        ArrayList<user> list = new ArrayList<>();

        //键盘录入学生的信息并添加到集合当中
        Scanner sc = new Scanner(System.in);

        for (int i = 0; i < 3; i++) {
            user s= new user();
            System.out.println("请输入学生的ID：");
            String s1=sc.next();
            System.out.println("请输入学生的帐户：");
            String s2=sc.next();
            System.out.println("请输入学生的密码：");
            String s3=sc.next();

            //把 setId 和 setUsername 和 setPassword 赋值给学生对象
            s.setId(s1); s.setUsername(s2); s.setPassword(s3);



            //把学生对象添加到集合当中
            list.add(s);
        }
        System.out.println("请输入要查找的ID:");
        String ss=sc.next();
        System.out.println(findD(ss,list));


    }

    public static boolean findD(String id,ArrayList<user> list){
        for(int i = 0 ; i<list.size(); i++){
            user s = list.get(i);
            String uid = s.getId();
            if(uid.equals(id)){
                return true;
            }
        }
        return false;

    }
}

user.java

package day6;

public class user {
    String id;
    String username;
    String password;

    public user() {
    }

    public user(String id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

添加手机对象并返回要求的数据

day6.java

package day6;
        import javax.lang.model.element.NestingKind;
        import java.sql.Struct;
        import java.util.ArrayList;
        import java.util.Scanner;

public class index {
    public static void main(String[] args) {
        //创建集合   不能写Int类型，要写Int类型对应的包装类
        ArrayList<phone> list = new ArrayList<>();

        //键盘录入学生的信息并添加到集合当中
        phone p1=new phone("小米",1000);
        phone p2=new phone("苹果",8000);
        phone p3=new phone("锤子",2999);

            //把学生对象添加到集合当中
        list.add(p1);
        list.add(p2);
        list.add(p3);
        findD(list);
        }



    public static void findD(ArrayList<phone> list){
        for(int i = 0 ; i<list.size(); i++){
            phone s = list.get(i);
            int uid = s.getPrice();
            if(uid<3000){
                System.out.println(s.getName()+","+s.getPrice());
            }
        }


    }
}

phone.java

package day6;

public class phone {

    String name;
    int price;

    public phone() {

    }

    public phone(String name, int price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }
}

学生管理系统

day7.java

package day7;

import day6.phone;
import day6.user;

import javax.lang.model.element.NestingKind;
import java.util.ArrayList;
import java.util.Scanner;

public class index {
    public static void main(String[] args) {
        ArrayList<student> list = new ArrayList<>();
        Scanner sc=new Scanner(System.in);

        //录入学生的信息并添加到集合当中
//        student p1=new student("2019042152","张三",18,"当阳市");
//
//        list.add(p1);
        while (true){
        startShow();
        int a=sc.nextInt();
        //添加功能:
        if(a==1){
            studentAdd(list);
        }else if(a==2){
            studentDel(list);
        }else if(a==3){
            studentResult(list);
        }else if(a==4){
            studentShow(list);
        }else if(a==5){
            break;
        }
        }

    }
    // 界面显示
    public static void startShow(){
        Scanner sc=new Scanner(System.in);
        System.out.println("\n-----------------------欢迎来到黑马学生管理系统-----------------------");
        System.out.println("1:添加学生");
        System.out.println("2:删除学生");
        System.out.println("3:修改学生");
        System.out.println("4:查询学生");
        System.out.println("5:退出");
        System.out.println("请输入您的选择:");

    }

    //添加
    public static void studentAdd( ArrayList<student> list){
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入学生的ID");
        String id=sc.next();
        System.out.println("请输入学生的姓名");
        String name=sc.next();
        System.out.println("请输入学生的年龄");
        int age=sc.nextInt();
        System.out.println("请输入学生的家庭住址");
        String address=sc.next();




            int bool=studentBool(list,id);
            if(bool>=0){
                System.out.println("该学生ID已存在！");

            }else{
                student s = new student(id,name,age,address);
                list.add(s);
                System.out.println("添加成功");

            }

//        startShow();


    }
        // 删除
        public static void studentDel(ArrayList<student> list){
            Scanner sc=new Scanner(System.in);
            System.out.println("请输入要删除的学生的ID");
            String s=sc.next();
            int bool=studentBool(list,s);
            if(bool>=0){
                list.remove(bool);
                System.out.println("删除成功");

            }else{
                System.out.println("没有该学生ID!");

            }
//            startShow();
            }


        // 修改
        public static void studentResult(ArrayList<student> list){
            Scanner sc=new Scanner(System.in);
            System.out.println("请输入要修改的学生的ID");
            String s=sc.next();
            int bool=studentBool(list,s);
            if(bool>=0){
            System.out.println("请输入修改后学生的ID");
            String id=sc.next();
            System.out.println("请输入修改后学生的姓名");
            String name=sc.next();
            System.out.println("请输入修改后学生的年龄");
            int age=sc.nextInt();
            System.out.println("请输入修改后学生的家庭住址");
            String address=sc.next();

            student ss=new student(id,name,age,address);
            list.set(bool,ss);
            System.out.println("修改成功");

            }else{
                System.out.println("没有该学生ID!");

            }
//            startShow();
        }

        //查询学生信息
        public static void studentShow(ArrayList<student> list){

            if(list.size()!=0) {
                System.out.println("id\t\t\t姓名\t年龄\t家庭地址");
                for (int i = 0; i < list.size(); i++) {
                    student ss = list.get(i);
                    System.out.println(ss.getId()+"\t"+ss.getName()+"\t"+ss.getAge()+"\t\t"+ss.getAddress());
                }
            }
            else{
                    System.out.println("当前无学生信息，请添加后再查询");

                }

//            startShow();
        }

        //判断ID唯一性
        public static int studentBool(ArrayList<student> list,String id){

            //判断ID唯一性
            for (int i = 0; i < list.size(); i++) {
                student ss = list.get(i);
                String studentId=ss.getId();
                if(studentId.equals(id)){
                    return i;
                }
            }
            return -1;

        }

}

student.java

package day7;

public class student {

    String id;
    String name;
    int age;
    String address;

    public student() {
    }

    public student(String id, String name, int age, String address) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    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 String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

面向对象进阶

static

被static修饰的成员变量，叫做静态变量	被static修饰的成员方法，叫做静态方法
特点：被该类所有对象共享	特点：多用在测试类和工具类中
调用方式：1.类名调用 2.对象名调用	调用方式：1.类名调用 2.对象名调用

Student.java

package day9;

public class Student {

    // 属性：姓名 年龄 性别
    private String name;
    private int age;
    private String gender;
    public static String teacherName;
    // static 表示静态

    public Student() {
    }

    public Student(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    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 String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    //行为
    public void study(){
        System.out.println(name+"正在学习");
    }

    public void show(){
        System.out.println(name + "," + age +  "," + gender + "," + teacherName);
    }
}

index.java

package day9;

public class index {
    public static void main(String[] args) {
        Student.teacherName = "阿伟老师";
        //1.创建一个新的学生对象
        Student s1= new Student();
        s1.setName("小王");
        s1.setAge(18);
        s1.setGender("男");
        //s1.teacherName="阿玮老师";

        s1.study();
        s1.show();


        //2.创建一个新的学生对象
        Student s2= new Student();
        s2.setName("小美");
        s2.setAge(20);
        s2.setGender("女");

        s2.study();
        s2.show();
    }
}

工具类

帮助我们做一些事情的，但是不描述任何事物的类

Javabean类	测试类	工具类
用来描述一类事物的类。比如：Student,Teacher,Dog,Cat等	用来检查其他类是否书写正确，带有main方法的类，是程序的入口	不是用来描述一类事物的，而是帮我们做一些事情的类

工具类
1、类名见名知意
2、私有化构造方法	public class Student { private Student(){} }
3、方法定义为静态	public class Student { private Student(){ public static int getMax { } } }

定义数组工具类

ArrayUtil.java

package day9;

public class ArrayUtil {

    //私有化构造方法
    //目的：为了不让外界创建他的对象
    private ArrayUtil(){}

        // 需要定义为静态的，方便调用
        public static String printArr(int[] arr){
            StringBuilder sb= new StringBuilder();
            sb.append("[");
            for (int i = 0; i < arr.length; i++) {
                //i索引arr[i]元素
                if(i==arr.length-1){
                    sb.append(arr[i]+",");
                }else {
                    sb.append(arr[i]);
                }
            }
            sb.append("]");
            return sb.toString();
        }

        public static Double getAerage(double[] arr){
            double sum=0;
            for (int i = 0; i < arr.length; i++) {
                sum+=arr[i];
            }
            return sum/arr.length;
        }
    }

index.java

package day9;

import java.lang.reflect.Array;
import java.net.SocketTimeoutException;

public class index {
    public static void main(String[] args) {
       int arr1[]={1,2,3,4,5,};
       String s=ArrayUtil.printArr(arr1);
        System.out.println(s);

        double arr2[]={1.5,3.7,4.9,5.8,6.6};
        double avg= ArrayUtil.getAerage(arr2);
        System.out.println(avg);

    }
}

定义学生工具类

StudentUtil.java

package day9;

import java.util.ArrayList;

public class StudentUtil {

    private StudentUtil(){}

    public static int getMax( ArrayList<Student> list){
        int max = list.get(0).getAge();

        for (int i = 0; i < list.size(); i++) {
            int age=list.get(i).getAge();
            if(age>max){
                max=age;
            }
        }
        return max;
    }
}

Student.java

package day9;

import java.util.ArrayList;

public class Student {
    private String name;
    private int age;
    private String sex;

    public Student() {
    }

    public Student(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }


    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 String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

index.java

package day9;

        import java.lang.reflect.Array;
        import java.net.SocketTimeoutException;
        import java.util.ArrayList;

public class index {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();

        Student stu1= new Student("张三",23,"男");
        Student stu2= new Student("李四",18,"男");
        Student stu3= new Student("小美",20,"女");

        list.add(stu1);
        list.add(stu2);
        list.add(stu3);

        int maxAgeStudent=StudentUtil.getMax(list);

        System.out.println(maxAgeStudent);


    }
}

static的注意事项

静态方法中，只能访问静态
非静态方法可以访问所有
静态方法中没有this关键字

继承

public class Student extends Person{}
			   |			  |
		  子类(派生类)		父类(基类或超类)
                   
                   
// 子类可以得到父类的属性和行为，子类可以使用
// 子类可以在父类的基础上新增其他功能，子类更强大
                   
          
特点：'Java只支持单继承，不支持多继承，但支持多层继承'
      单继承：一个子类只能继承一个父类
      不支持多继承：子类不能同时继承多个父类
      多层继承：子类A 继承 父类B, 父类B 可以 继承父类C
       
                   
      '子类到底能继承父类中的哪些内容？
      -----------------------------------------
      构造方法	   非私有 不能		private 不能
      成员变量	   非私有 能		 private 能(但不能直接使用)
      成员方法	   非私有 能		 private 不能

多层继承

构造方法

构造方法非私有不能继承父类 private 不能继承父类

成员变量

成员变量非私有能继承父类 private 能(但不能直接使用)

方法成员

成员方法非私有能继承父类 private 不能继承父类

继承中：成员变量的访问特点

继承中：成员方法的访问特点

练习：利用方法的重写设计继承结构

package day9;
public class index {
    public static void main(String[] args) {
        //创建对象并调用
        Husky h = new Husky();
        h.eat();
        h.drink();
        h.lookHome();
        h.breakHome();

        ChineseDog cd= new ChineseDog();
        cd.eat();
        cd.drink();
        cd.lookHome();

    }

}

class Dog{

    public void eat(){
        System.out.println("狗吃狗粮");
    }
    public void drink(){
        System.out.println("狗在喝水");
    }
    public void lookHome(){
        System.out.println("狗在看家");
    }
}

class Husky extends Dog{

    //哈士奇拆家
    public void breakHome(){
        System.out.println("哈士奇在拆家");
    }

}

class SharPei extends Dog{  //沙皮狗

    //沙皮狗吃狗粮和骨头
    @Override
    public void eat() {
        super.eat();
        System.out.println("狗吃骨头");
    }
}

class ChineseDog extends Dog{  //沙皮狗

    //沙皮狗吃狗粮和骨头
    @Override
    public void eat() {
        System.out.println("狗吃剩饭");
    }
}

继承中：构造方法的特点

多态

Text.java 父类

package day11;

import javafx.scene.AmbientLight;

public class Text {
    public static void main(String[] args) {

        Student s= new Student();
        s.setName("张三");
        s.setAge(18);

        Teacher t = new Teacher();
        t.setName("王建国");
        t.setAge(30);

        Adminstrator admin= new Adminstrator();
        admin.setName("管理员");
        admin.setAge(35);

        register(s);
        register(t);
        register(admin);
    }

    // 可以显示 Student/Teacher/Adminstrator的信息，用他们的父类
    public static void register(Person p){
    p.show();
    }
}

Person.java 父类

package day11;

import day10.Printer;

public class Person {

    private String name;
    private int age;

    public void show(){
        System.out.println(name + "," + age);
    }

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = 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;
    }
}

Student.java 子类

package day11;

public class Student extends Person {

    @Override
    public void show() {
        System.out.println("学生的信息为：" + getName() + "," + getAge());
    }
}

Teacher.java 子类

package day11;

public class Teacher extends Person {
    @Override
    public void show() {
        System.out.println("老师的信息为：" + getName() + "," + getAge());
    }
}

Adminstrator.java 子类

package day11;

public class Adminstrator extends Person {
    @Override
    public void show() {
        System.out.println("管理员的信息为：" + getName() + "," + getAge());
    }
}

多态的优势和弊端

instanceof

多态综合练习

index.java

package day12;

public class index {
    public static void main(String[] args) {
    Person p= new Person("老王",30);

    Dog d=new Dog(2,"黑");
    p.keePet(d,"骨头");

    Cat c=new Cat(3,"灰");
    p.keePet(c,"鱼");
    }
}

Animal.java

package day12;

public class Animal {

    private int age;
    private String color;

    public Animal() {
    }

    public Animal(int age, String color) {
        this.age = age;
        this.color = color;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public void eat(String something){
        System.out.println(something);
    }
}

car.java

package day12;

public class Cat extends Animal{
    public Cat() {
    }

    public Cat(int age, String color) {
        super(age, color);
    }

    @Override
    public void eat(String something) {
        super.eat(getAge()+"岁的"+getColor()+"颜色的猫眯着眼睛侧着头吃"+something+"\n");
    }
}

dog.java

package day12;

public class Dog  extends  Animal{
    public Dog() {
    }

    public Dog(int age, String color) {
        super(age, color);
    }

    @Override
    public void eat(String something) {
        super.eat(getAge()+"岁的"+getColor()+"颜色的狗两只前腿死死的抱住"+something+"猛吃\n");
    }
}

Person.java

package day12;

import java.util.zip.CheckedOutputStream;

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = 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 void keePet(Animal a,String something){
       if(a instanceof Dog){
        Dog d=(Dog) a;
        System.out.println("年龄为"+getAge()+"岁的"+getName()+"养了一只"+a.getColor()+"颜色的"+a.getAge()+"岁的狗");
        d.eat(something);
        } else if(a instanceof Cat){
           Cat c=(Cat) a;
           System.out.println("年龄为"+getAge()+"岁的"+getName()+"养了一只"+a.getColor()+"颜色的"+a.getAge()+"岁的猫");
           c.eat(something);
       }else{
           System.out.println("没有这个动物");
       }
    }
}

包、final、权限修饰符、代码块

抽象类

1.抽象类不能实例化（抽象类不能创建对象）

2.抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

3.可以有构造方法

4.抽象类的子类

抽象类为父类时
子类要么是也是抽象类 (但会无法创建对象) 不常用
要么重写父类中的所有抽象方法（可以创建对象）常用

综合练习

index.java

package day13;

public class index {
    public static void main(String[] args) {
        //创建对象

        frog f=new frog("小绿",1);

        System.out.println(f.getName()+","+f.getAge());
        f.drink();
        f.eat();
    }
}

Animal.java

package day13;

public abstract class Animal {
    private String name;
    private int age;


    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = 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 abstract void eat();



    public void drink(){
        System.out.println("动物在喝水");
    }
}

Dog.java

package day13;

public class Dog extends Animal {


    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

frog.java

package day13;

public class frog extends Animal {

    public frog() {
    }

    public frog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("青蛙吃虫子");
    }
}

Sheep.java

package day13;

public class Sheep extends  Animal {


    public Sheep() {
    }

    public Sheep(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("山羊吃草");
    }
}

接口

接口的定义和使用

接口常运用于子类，抽象常运用于父类
接口就是一种规则，是对行为的抽象

接口练习使用

Test.java

package day14;

public class Test {
    public static void main(String[] args) {

        //青蛙的对象
        Frog f = new Frog("小青",1);
        System.out.println(f.getName() + "," + f.getAge());

        f.eat();
        f.swim();

    }
}

Animal.java

package day14;

public abstract class Animal {

    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = 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 abstract void eat();
}

Swim.java(接口)

package day14;

public interface Swim  {
    public abstract void swim();
}

Frog.java

package day14;

public class Frog extends  Animal implements Swim{
         //  青蛙子类     动物父类         接口


    public Frog() {
    }

    public Frog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("吃虫子");
    }

    @Override
    public void swim() {
        System.out.println("蛙泳");
    }
}

Dog.java

package day14;

public class Dog extends  Animal implements Swim {
         //  青蛙子类     动物父类         接口
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("吃骨头");
    }

    @Override
    public void swim() {
        System.out.println("狗刨");
    }
}

Rabbit.java

package day14;

public class Rabbit extends Animal{



    public Rabbit() {
    }

    public Rabbit(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("吃胡萝卜");
    }

}

接口的细节：成员特点和接口的各种关系

综合练习

分析

Test.java

package day15;

public class Test {

    public static void main(String[] args) {

        //创建对象
        PingPangCoach p1= new PingPangCoach("张三",25);
        System.out.println(p1.getName()+","+p1.getAge());
        p1.teach();p1.speakEnglish();

    }
}

Proson.java

package day15;

//因为现在我不想让外界去直接创建人的对象
//因为直接创建项层父类人的对象此时是没有意义的
//所以我就把他写为抽象的。
public abstract class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = 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;
    }


}

Sporter.java

package day15;

public abstract class Sporter extends Person{
    //运动员

    public Sporter() {
    }

    public Sporter(String name, int age) {
        super(name, age);
    }

    public abstract void study();

}

Coach.java

package day15;

public abstract class Coach extends  Person {
	//教练
    public Coach() {
    }

    public Coach(String name, int age) {
        super(name, age);
    }

    public abstract void teach();
}

English.java

package day15;

public interface English {
//接口
    public abstract  void speakEnglish();

}

PingPangSporter.java

package day15;

public  class PingPangSporter extends Sporter implements English {
//乒乓球运动员

    public PingPangSporter() {
    }

    public PingPangSporter(String name, int age) {
        super(name, age);
    }

    @Override
    public void speakEnglish() {
        System.out.println("乒乓球运动员在说英语");
    }

    @Override
    public void study() {
        System.out.println("乒乓球运动员在学打乒乓球");
    }
}

PingPangCoach.java

package day15;

public class PingPangCoach extends Coach implements English {
//乒乓球教练
    public PingPangCoach() {
    }

    public PingPangCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("乒乓球教练教乒乓球运动员打乒乓球");
    }

    @Override
    public void speakEnglish() {
        System.out.println("乒乓球教练在说英语");
    }
}

BasketBallCoach.java

package day15;

public class BasketBallCoach extends Coach {
//篮球教练
    public BasketBallCoach() {
    }

    public BasketBallCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("篮球教练教篮球运动员打篮球");
    }
}

BasketBallSporter.java

package day15;

public class BasketBallSporter extends Sporter {
//篮球运动员
    public BasketBallSporter() {
    }

    public BasketBallSporter(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println("篮球运动员在学习打篮球");
    }
}

内部类

类的五大成员：
属性、方法、构造方法、代码块、内部类

基本使用

成员内部类(了解)

写在成员位置的，属于外部类的成员

public class Car { //外部类
String carName;
int carAge ;
int carColor;
class Engine{ //成员内部类
String engineName;
int engineAge ;
	}
}

静态内部类(了解)

局部内部类(了解)

匿名内部类(掌握)

格式：
    new 类名或者接口名(){
    重写方法;
}

运用场景

常用API

快速过一遍，多用用 JDK-API 查一查

Math

用法：Math.方法名()

System

System.方法名()

计算机中的时间原点 1970年1月1日 00:00:00 我们国家 1970年1月1日 08:00:00

package day18;
public class Test {
    public static void main(String[] args) {

        //0  ： 表示当前虚拟机是正常停止
       //非0 ： 表示当前虚拟机异常停止
        System.exit(0);
        System.out.println("看看我执行了吗？");

        }
}

package day18;
public class Test {
    public static void main(String[] args) {

        long l = System.currentTimeMillis();
        System.out.println(l);
    }

}

package day18;
public class Test {
    public static void main(String[] args) {

       //拷贝数组
        int[] arr1 = {1,2,3,4,5,6,7,8,9,10};
        int[] arr2 = new int[10];
        //把arr1数组中的数据拷贝到arr2中
        //参数一: 数据源，要拷贝的数据从哪个数组
        //参数二: 从数据源数组中的第几个索引开始拷贝
        //参数三: 目的地，我要把数据拷贝到哪个数组中
        //参数四: 目的地数的索引。
        //参数五: 拷贝的个数
        System.arraycopy(arr1,0,arr2,0,10);

        //检测
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i] + " ");
        }
    }

}

Runtime

Runtime.方法名()

package day18;

import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {

      //1.获取Runtime的对象
        Runtime r1=Runtime.getRuntime();

        //2.exit 停止虚拟机
//        r1.exit(0);

        //3.获取CUP的线程数
        System.out.println(r1.availableProcessors());   //8

        //4.总内在大小
        System.out.println(r1.maxMemory()/1024/1024);

        //5.已经获取的总内存大小，单位byte字节
        System.out.println(r1.totalMemory()/1024/1024);

        //6.剩余内存大小
        System.out.println(r1.freeMemory()/1024/1024);

        //7.运行cmd命令
        //shutdown:关机
        //加上参数才能执行
        //-s : 默认在1分钟之后关机
        //-s -t 指定时间 : 指定关机时间           shutdown -s -t 3600     一小时后关机
        //-a : 取消关机操作.
        //-r : 关机并重启

        r1.exec("notepad");
    }

}

Object

方法名	说明
public String toString()	返回对象的字符串表示形式
public boolean equals(Object obj)	比较两个对象是否相等
protected Object clone(int a)	对象克隆

package day19;

import java.util.Random;
import java.util.Scanner;

public class index {
    public static void main(String[] args) {

        //toString 返回对象的字符串表示形式
        Object obj=new Object();
        String str1=obj.toString();
        System.out.println(str1);

        //equals
        Student s1=new Student();
        Student s2=new Student();
        boolean result1 = s1.equals(s2);
        System.out.println(result1);


        }
}