Java基础学习

Java基础学习

卸载jdk

  1. 删除java的安装路径

  2. 环境变量---JAVA_HONE

  3. 删除path下面关于java的目录

  4. cmd 查看 java -version

安装jdk

  1. 百度搜索jdk8，找到下载地址

  2. 同意协议

  3. 下载电脑对应版本

  4. 双击进行安装4

  5. 记住安装路径 --配置环境变量

    点击跳转环境变量配置步骤

  6. 检查是否安装成功 cmd 输入 java -version

Java -- 注释

 

  • 单行注释

        // 输出一个helloword
    public static void main(String[] args){
        System.out.print("Hello World");
    }

  • 多行注释

    public static void main(String[] args){
         /*
         我是多行注释 可以注释一段文字
         输出一个helloword
         */
        System.out.print("Hello World");
    }

  • 文本注释 /** */

    public static void main(String[] args){
         /**
         我是文本注释 可以注释一段文字
         输出一个helloword
         */
        System.out.print("Hello World");
    }

Java -- 标识符和关键字

  • 所有的标识符都应该以字母、美元$、或者下划线_ 开始

  • 首字母之后可以是任意字母、任意字符

  • 不用使用关键字作为变量名或方法名

  • 标识符是大小写敏感的

    合法标识符举例：age、$salary、_value、__1_value

    非法的标识符举例：123abc、-salary、#abc

    String age = "10";
    String $value = "10.00";

     

数据类型

强类型语言

要求变量的使用严格符合规定，所有变量都必须先定义后使用

String a = "hello";//正确
String a = 10; //错误
int a = 10 ; 正确形式

弱类型语言（js）

 

基本类型

image-20220621145048945

// 八大基本数据类型
// 整数
int num1= 10;
byte num2= 20;
short num3 = 30;
long num4 = 30L; // Long 类型要在数字后面加L
// 小数
float num5 = 50.1F; // float 类型要在数字后面加F
double num6 = 3.1515626;
// 字符
char name = "A";
// 字符串 ，String 不是关键字，是一个类
String name ="您好";
​
//布尔值 ：是非
boolean flag = true;

转义字符

// \t 制表符
// \n 换行符
System.out.printIn("Hello\tWord");

类型转换

image-20220621152838285

public static void main(Stringp[] args){
    int i= 128; // 输出128
    byte b = (byte)i; // 内存溢出  输出-128
    
    // 强制转换  （类型）变量名  高--低
    // 自动转换   低--高
     int i= 128; // 输出128
     double b = i;  // 输出128.0
    
    /** 注意点：
     1.不能对boolean进行转换
     2.不能把对象的类型转换为不相干的类型
     3.把高容量转换为低容量的时候，强制转换
     4.转换的时候可能存在内存溢出，或者精度的问题
     */
    System.out.printIn((int)23.7); // 23
    System.out.printIn((int)-23.79f); // -23
    
    
    // 操作比较大数的时候，注意溢出问题
    // JDK7新特性，数字之间可以用下划线分割
    int money = 10_0000_0000;
    int years = 20;
    int total = money*years; // -1474836480 ,计算的时候溢出了
    
    long total2 = money*((long)years); // 先把一个数转换为long 输出正常
    
}

变量

注意：1.每个变量都要有类型，类型可以是基本类型，也可以是引用类型

2.变量名必须是合法的标识符

3.变量声明是一个完整的语句，因此每一个声明都必须以分号结束。

public static void main(Stringp[] args){
 int a=1,b=2,c=3;   // 不建议使用
    String name = "hello";
    char x= "X";
}

变量作用域

类变量

实例变量

局部变量

public class Demo{
    // 类变量 static
    static double salary=2500;
    
    // 属性：变量
    
    // 实例变量   从属于对象;
    // 如果不自行初始化，输出这个类型默认值
    // boolean 值默认输出 false ,除了基本类型其余默认值为null;
    String name ; 
    String age ;
    
    // main方法
   public static void main(Stringp[] args){
       // 局部变量 ，必须声明和初始化值
       int i= 10;
       System.out.pringtIn(i);
       
       //变量类型
       Demo demo = new Demo();
       demo.age;
       // 类变量 static
       System.out.pringtIn(salary);
   }
    // 其他方法
    public void add(){
        
    }
}

命名规范

image-20220621163937851

 

运算符

image-20220621164338455

public class Demo{
    public static void main(String[] args){
        // ++ -- 自增 自减  一元运算法
        int a = 3;
        int b = a++ ; //  输出4 a++ = a + 1  先赋值 再自增
        int c = ++a ; //  输出5  先自增 后赋值
        // 幂运算 2*2*2 = 8,很多运算会使用工具类来运算
        double pow = Math.pow(2,3);
    }
}
public class Demo{
    public static void main(String[] args){
        // 逻辑运算符
        // 与（and）  或(or)   非(取反)
        boolean a = true;
        boolean a = false;
        
        System.out.printIn("a&&b:"+(a&&b));// 逻辑与运算 ：两个变量都为真，结果才为true
        System.out.printIn("a||b:"+(a||b));// 逻辑或运算 : 两个变量有一个为真，结果为true
        System.out.printIn("!(a&&b):"+!(a&&b));// 逻辑非运算
    }
}
public class Demo{
    public static void main(String[] args){
        // 位运算
        /**
        A = 0011 1100
        B = 0000 1101
        A&B 0000 1100
        A|B 0011 1101
        A^B 0011 0001 异或
        ~B  1111 0010 取反
        
        面试题：
        2*8 = 16     2*2*2*2 
        <<  >>   左移  右移
        */
        
        0000 0000 0
        0000 0001 1
        0000 0010 2
        0000 0011 3
        0000 0100 4
        0000 1000 8
        0001 0000 16
    }
}
public class Demo{
    public static void main(String[] args){
        int a = 10 ; 
        int b = 20 ;
        
        a+=b ; // a= a+b 
        a-=b ; // a= a-b;
        System.out.printIn(""+a+b); // 输出 1020字符串
        System.out.printIn(a+b+""); // 输出 30
         
        // 三元运算符 x==v?y:z;
        
    }
}

包机制

一般利用公司域名倒置作为包名 如：com.baidu.www

阿里巴巴操作手册

JavaDoc -- 用来生成自己的API文档


/**
@author tanlq
@version 1.0
@since 1.8 jdk版本
*/
public class doc{
    String name ;
    /**
	@author tanlq
	@param name
	@return
	@thorws Exception
	*/
    public String test(String name) throws Exception{
    	
    	return name;
    }
}

image-20220622143255152

编译成doc文本：

image-20220622143729053

 

 

Java 流程控制

Scanner对象 -- 获得用户的输入 实现人和程序的交互

Scanner s = new Scanner(System.in);
​
package com.gentlesoft.oa.archives.controller;
​
import java.util.Scanner;
​
public class Demo01 {
​
    public static void main(String[] args) {
     // 创建一个扫描器对象，用于接受键盘的数据
      Scanner scanner = new Scanner(System.in);
​
      System.out.println("使用next方式接收：");
       // 判断用户有没有输入字符串
      if(scanner.hasNext()){
          //使用next方式接收}
        String str = scanner.next();
        System.out.println("输出的内容为："+str);
    }
      // 凡是属于IO流的类如果不关闭就会一直占用资源，要养成良好的习惯
      scanner.close();
    }
}
​

输出结果：

image-20220622150631326

package com.gentlesoft.oa.archives.controller;
​
import java.util.Scanner;
​
public class Demo01 {
​
    public static void main(String[] args) {
     // 创建一个扫描器对象，用于接受键盘的数据
      Scanner scanner = new Scanner(System.in);
​
      System.out.println("使用nextline方式接收：");
       // 判断用户有没有输入字符串
      if(scanner.hasNextLine()){
          //使用nextline方式接收}
        String str = scanner.nextLine();
        System.out.println("输出的内容为："+str);
    }
      // 凡是属于IO流的类如果不关闭就会一直占用资源，要养成良好的习惯
      scanner.close();
    }
}
​

输出结果为：

image-20220622150905879

区别：

image-20220622151012129

import java.util.Scanner;

public class Demo01 {

    public static void main(String[] args) {
     // 创建一个扫描器对象，用于接受键盘的数据
      Scanner scanner = new Scanner(System.in);

      System.out.println("请输入数据：");
      String str = scanner.nextLine();
      System.out.println("输出的内容为："+str);
      // 凡是属于IO流的类如果不关闭就会一直占用资源，要养成良好的习惯
      scanner.close();
    }
}

image-20220622151531697

Scanner 进阶

package com.gentlesoft.oa.archives.controller;

import java.util.Scanner;

public class Demo01 {

    public static void main(String[] args) {
     // 创建一个扫描器对象，用于接受键盘的数据
      Scanner scanner = new Scanner(System.in);
      // 从键盘接受数据
        int i = 0;
        float f=  0.0f;
        System.out.println("请输入整数 ： ");
        if(scanner.hasNextInt()){
            i=scanner.nextInt();
            System.out.println("整数数据："+i);
        }else{
            System.out.println("输入的不是整数数据：");
        }

        System.out.println("请输入小数 ： ");
        if(scanner.hasNextFloat()){
            f=scanner.nextFloat();
            System.out.println("小数数据："+f);
        }else{
            System.out.println("输入的不是小数数据：");
        }
      // 凡是属于IO流的类如果不关闭就会一直占用资源，要养成良好的习惯
      scanner.close();
    }
}

image-20220622152321901

package com.gentlesoft.oa.archives.controller;

import java.util.Scanner;

public class Demo01 {

    public static void main(String[] args) {
     // 创建一个扫描器对象，用于接受键盘的数据
        // 输入多个数字，求和和求平均数
      Scanner scanner = new Scanner(System.in);
      // 从键盘接受数据 求和
        double sum = 0;
        // 计算输入多少个数字
        int m = 0;

        // 通过循环判断是否还有输入，并在里面对每一次进行求和统计
        while(scanner.hasNextDouble()){
            double x = scanner.nextDouble();
            m = m + 1;
            sum = sum + x;
            System.out.println("你输入第："+m+"个数据，当前结果为："+sum);
        }
        System.out.println(m+"个数的和为："+sum);
        System.out.println(m+"个数的平均值为："+(sum/m));
      // 凡是属于IO流的类如果不关闭就会一直占用资源，要养成良好的习惯
      scanner.close();
    }
}

image-20220622153708831

选择结构

if单选结构

package com.gentlesoft.oa.archives.controller;
​
import java.util.Scanner;
​
public class Demo01 {
​
    public static void main(String[] args) {
     // 创建一个扫描器对象，用于接受键盘的数据
      Scanner scanner = new Scanner(System.in);
        System.out.println("请输入内容");
        String s = scanner.nextLine();
        if(s.equals("Hello")){
            System.out.println(s);
        }
      // 凡是属于IO流的类如果不关闭就会一直占用资源，要养成良好的习惯
      scanner.close();
    }
}
​

if双选结构

package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {
​
    public static void main(String[] args) {
     // 创建一个扫描器对象，用于接受键盘的数据
      Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩: ");
        int s = scanner.nextInt();
        if(s>60){
            System.out.println("成绩及格");
        }else{
            System.out.println("成绩不及格");
        }
      // 凡是属于IO流的类如果不关闭就会一直占用资源，要养成良好的习惯
      scanner.close();
    }
}
​

image-20220623143535396

 

if 多选结构

package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {

    public static void main(String[] args) {
     // 创建一个扫描器对象，用于接受键盘的数据
      Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩: ");
        int s = scanner.nextInt();
        if(s==100){
            System.out.println("成绩为：S+");
        }else if(s>=90&&s<100){
            System.out.println("成绩为：A");
        }else if(s>=80&&s<90){
            System.out.println("成绩为：B");
        }else if(s>=0&&s<80){
            System.out.println("成绩为：C");
        }else{
            System.out.println("成绩不合法");
        }
      // 凡是属于IO流的类如果不关闭就会一直占用资源，要养成良好的习惯
      scanner.close();
    }
}

image-20220623144103993

嵌套的if结构

switch多选择结构

package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {

    public static void main(String[] args) {
     char grade = 'C';
     switch (grade){
         case 'A':
             System.out.println("优秀");
             break;
         case 'B':
             System.out.println("良好");
             break;
         case 'C':
             System.out.println("及格");
             break;
         case 'D':
             System.out.println("加油");
             break;
         default:
             System.out.println("挂科");
     }
    }
}
package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {

    public static void main(String[] args) {
        // 字符串进行比较
     String name = "老谭学java";
     switch (name){
         case "老谭学java":
             System.out.println("老谭学java");
             break;
         case "老谭":
             System.out.println("老谭");
             break;
         default:
             System.out.println("输出的不正确");
     }
    }
}
//输出：老谭学java

While循环

while 循环

package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {

    public static void main(String[] args) {
       // 输出1到100
        int i = 1 ;
        while(i<100){
            i++;
            System.out.println(i);
        }
    }
}
=========
package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {

    public static void main(String[] args) {
        // 输出1+到100
        int i = 0 ;
        int sum = 0;
        while(i<=100){
            sum+=i;
            i++;
        }
        System.out.println(sum);
    }
}

do .... while 循环 --- 先执行后判断

package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {

    public static void main(String[] args) {
        // 输出1+到100
        int i = 0 ;
        int sum = 0;
        do{
            sum+=i;
            i++;
        }while(i<=100);
            System.out.println(sum);
    }
}
//区别
package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {
​
    public static void main(String[] args) {
        // 输出1+到100
        int i = 0 ;
        while(i<0){
            System.out.println(i);
            i++;
        }
        System.out.println("===========");
        // do ... while 至少执行一次
        // while 只有符合条件才会执行
        do{
            System.out.println(i);
            i++;
        }while(i<0);
           
    }
}
//========输出=======
===========
​

for 循环

package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {
​
    public static void main(String[] args) {
        // 计算0到100之间奇数和偶数的和
        int jishuSum = 0;
        int oushuSum = 0;
        for (int i = 0; i < 100; i++) {
            if(i%2!=0){//基数
                jishuSum+=i;
            }else{//偶数
                oushuSum+=i;
            }
        }
        System.out.println("基数的和为："+jishuSum);
        System.out.println("偶数的和为："+oushuSum);
    }
}
//基数的和为：2500
//偶数的和为：2450
package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {
​
    public static void main(String[] args) {
        // 计算1到1000之间能被5整除的数，并且每行输出三个
        for (int i = 0; i <= 1000; i++) {
            if(i%5==0){//基数
                System.out.print(i+"\t");
            }
            if(i%(5*3)==0){
                System.out.print("\n");
            }
        }
    }
}
​
package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {

    public static void main(String[] args) {
        // 打印九九乘法表
        for (int j = 1; j <= 9; j++) {
            for (int i = 1; i <= j; i++) {
                System.out.print(j + "*" + i + "=" + (j * i)+"\t");
            }
            System.out.println();
        }
    }
}
1*1=1	
2*1=2	2*2=4	
3*1=3	3*2=6	3*3=9	
4*1=4	4*2=8	4*3=12	4*4=16	
5*1=5	5*2=10	5*3=15	5*4=20	5*5=25	
6*1=6	6*2=12	6*3=18	6*4=24	6*5=30	6*6=36	
7*1=7	7*2=14	7*3=21	7*4=28	7*5=35	7*6=42	7*7=49	
8*1=8	8*2=16	8*3=24	8*4=32	8*5=40	8*6=48	8*7=56	8*8=64	
9*1=9	9*2=18	9*3=27	9*4=36	9*5=45	9*6=54	9*7=63	9*8=72	9*9=81

增加for循环

package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {

    public static void main(String[] args) {
        //增加for循环
        int[] number = {10,20,30,40,50};

        for (int x:number) {
            System.out.println(x);
        }
    }
}
package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {

    public static void main(String[] args) {
        //打印三角形 5行
        for (int i = 1; i <= 5; i++) {
            for (int j = 5; j >= i; j--) {
                System.out.print(" ");
            }
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            for (int j = 1; j < i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}
     *
    ***
   *****
  *******
 *********

 

Java 方法

方法的定义和调用

package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        int max = max(10,10);
        System.out.println(max);
    }
    // 比大小
    public static int max(int num1 , int num2){
        int result = 0;
        if(num1==num2){
            System.out.println("方法值相等");
            return 0 ;
        }
        if(num1>num2){
            result=num1;
        }else{
            result = num2;
        }
        return result;
    }
}
输出：
    方法值相等
	0

方法的重载

在一个类中，相同的方法名称，但是参数类型不同（参数个数、类型、排列顺序等不同）
    package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        int max = max(10,10);
        System.out.println(max);
    }
    // 比大小 ----方法一
    public static int max(int num1 , int num2){
        int result = 0;
        if(num1==num2){
            System.out.println("方法值相等");
            return 0 ;
        }
        if(num1>num2){
            result=num1;
        }else{
            result = num2;
        }
        return result;
    }
    // 方法二
        public static double max(double num1 , double num2){
        double result = 0.0;
        if(num1==num2){
            System.out.println("方法值相等");
            return 0.0 ;
        }
        if(num1>num2){
            result=num1;
        }else{
            result = num2;
        }
        return result;
    }
}

可变参数

package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        test(35,35.5,22.2);
        test(new double[]{1,2,3});
    }
    /**
     * 在方法声明中，再指定参数类型后加一个省略号（...）
     * 一个方法中只能指定一个可变参数，他是方法的最后一个参数，任何普通参数必须在他之前声明
     */
        public static void test(double ...i){
           if(i.length==0){
               System.out.println("没有数据输入");
               return;
            }
           double result = i[0];
           // 排序
            for (int j = 0; j < i.length; j++) {
                if(i[j]>result){
                    result=i[j];
                }
            }
            System.out.println("最大的值为："+result);
        }
}
// 输出
最大的值为：35.5
最大的值为：3.0

递归

package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        System.out.println(test(5));
    }
    // 计算 5*4*3*2*1阶乘
        public static int test(int n){
           if(n==1){
               return 1;
            }else{
               return n*test(n-1);
           }
        }
}
// 输出
120

数组

package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        // 定义一个数组
        int[]  nums; // 定义方式一
        int num2[];  // 定义方式二

        nums = new int[10];// 这里面可以存放10个类型的数字
        // 数组元素赋值
        nums[0]=1;
        nums[1]=2;
        nums[2]=3;
        nums[3]=4;
        nums[4]=5;
        nums[5]=6;
        nums[6]=7;
        nums[7]=8;
        nums[8]=9;
        nums[9]=10;
        System.out.println(nums[9]);

    }

}
package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        // 定义一个数组
        int[]  nums; // 定义方式一
        int num2[];  // 定义方式二
​
        nums = new int[10];// 这里面可以存放10个类型的数字
        // 数组元素赋值
        nums[0]=1;
        nums[1]=2;
        nums[2]=3;
        nums[3]=4;
        nums[4]=5;
        nums[5]=6;
        nums[6]=7;
        nums[7]=8;
        nums[8]=9;
        nums[9]=10;
        // 计算所有元素的和
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        System.out.println("总和为 ："+sum);
    }
​
}
// 输出为：总和为 ：55

内存分析

image-20220627100939865

package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        // 静态初始化 创建加赋值
        int[] a = {1,2,3,4,5,6};
        System.out.println(a[0]);
        // 动态初始化:包含默认初始化
        int[] b= new int[10];
        b[0]=10;
        System.out.println(b[0]);
    }
​
}
//输出
1
10

基本特征

  1. 数组的长度是确定的，一单被创建，大小是不可改变的

  2. 数组的元素必须是相同的数据类型，不能出现混合类型

  3. 数组中的元素可以使任何类型，包含基本类型和引用类型

  4. 数字变量属于引用类型，也可以看成一个对象

  5. 数组本身就是对象，对象是在堆中的。

数组边界

  1. 数组是相同数据类型的有序集合

  2. 数组也是独享，数组元素相当于对象的成员变量

  3. 数组的长度是确定的，不可变的。

数组的使用

for -each 循环

package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        // 静态初始化 创建加赋值
        int[] arrays = {1,2,3,4,5,6};
        // 打印全部的数组元素
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }
        System.out.println("===========");
        // 计算所有元素的和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            sum+=arrays[i];
        }
        System.out.println("sum : "+sum);
        // 查找最大值
        int max = arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            if(arrays[i]>max){
                max=arrays[i];
            }
        }
        System.out.println("max:"+max);
    }

}
// 输出
1
2
3
4
5
6
===========
sum : 21
max:6
package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        // 静态初始化 创建加赋值  for each
        int[] arrays = {1, 2, 3, 4, 5, 6};
        for (int arrsy:arrays
             ) {
            System.out.println(arrsy);
        }
    }
}

数组作为参数、作为返回值

package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        // 静态初始化 创建加赋值  for each
        int[] arrays = {1, 2, 3, 4, 5, 6};

        int[] reverse = reverse(arrays);
        printArrays(reverse);
    }
    // 打印数组元素
    public  static void  printArrays(int[] arrays){
        for (int arrsy:arrays
        ) {
            System.out.println(arrsy);
        }
    }
    // 反转元素
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        for (int i = 0,j = result.length-1;i < arrays.length; i++,j--) {
            result[j]=arrays[i];
        }
        return result;
    }
}

多维数组

package com.gentlesoft.oa.archives.controller;
import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {

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

Arrays类

package com.gentlesoft.oa.archives.controller;
import java.util.Arrays;
import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        int[] array = {1,22,33,4,65};
        Arrays.sort(array); // 排序
        System.out.println(Arrays.toString(array));
    }
}

冒泡排序

package com.gentlesoft.oa.archives.controller;
import java.util.Arrays;
import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        int[] array = {1,22,33,4,65,8};
        sort(array);
        System.out.println(Arrays.toString(array));
    }
​
    public static int[] sort(int[] array){
        // 冒泡排序
        int temp = 0;
        for (int i = 0; i < array.length-1; i++) {//轮次
            // 如果第一个数比第二个数打则交换位置
            boolean flag = false; // 通过flag标识减少没有意义的比较
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j+1]>array[j]){
                    temp = array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                    flag = true;
                }
            }
            if(flag==false){
                break;
            }
        }
        return array;
    }
}
​

稀疏数组

处理方式：

  1. 记录数组一共几行几列，有多少个不同的值

  2. 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模。

package com.gentlesoft.oa.archives.controller;
import java.util.Arrays;
import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        // 创建一个二位数组  11* 11   0:没有旗子  1：黑棋 2白旗
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;
        // 输出原始的数组
        System.out.println("输出原始的数组：");
        for (int[] ints : array) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        // 1.转换为稀疏数组进行保存
        // 获取有效值的个数
        System.out.println("==============");
        int sum = 0;
        for (int i = 0; i < array.length-1; i++) {
            for (int j = 0; j < array.length-1; j++) {
                if(array[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数为："+sum);
        // 2.创建一个稀疏数组的数组
        int[][] a = new int[sum+1][3];
        a[0][0] = 11;
        a[0][1] = 11 ;
        a[0][2] = sum;
        // 遍历二维数组，将非零的值 存放在稀疏数组中
        int count =  0 ;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if(array[i][j]!=0){
                    count++;
                    a[count][0]=i;
                    a[count][1]=j;
                    a[count][2]= array[i][j];
                }
            }
        }
        // 输出稀疏数组
        System.out.println("输出稀疏数组：");
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i][0]+"\t"
            +a[i][1]+"\t"
            +a[i][2]+"\t");
        }
        // 还原稀疏数组中的值
        System.out.println("=================");
        System.out.println("还原");
        // 1.读取稀疏数组
        int[][] array3 = new int[a[0][0]][a[0][1]];
        // 2.给其他的元素还原他的值
        for (int i = 1; i < a.length; i++) {
            array3[a[i][0]][a[i][1]] = a[i][2];
        }
        // 3.打印
        System.out.println("打印还原的数组");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}
​
输出：
输出原始的数组：
0   0   0   0   0   0   0   0   0   0   0   
0   0   1   0   0   0   0   0   0   0   0   
0   0   0   2   0   0   0   0   0   0   0   
0   0   0   0   0   0   0   0   0   0   0   
0   0   0   0   0   0   0   0   0   0   0   
0   0   0   0   0   0   0   0   0   0   0   
00000000000
00000000000
00000000000
00000000000
00000000000
==============
有效值的个数为：2
输出稀疏数组：
11112
121
232
=================
还原
打印还原的数组
00000000000
00100000000
00020000000
00000000000
00000000000
00000000000
00000000000
00000000000
00000000000
00000000000
00000000000

面向对象

以类的方式组织代码，以对象方式封装数据

package com.gentlesoft.oa.archives.controller;
import java.util.Arrays;
import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        
    }
​
    /**
     * 修饰符 返回值类型 方法名（）
     * @return
     */
    public String sayHello(){
        return "Hello World!!!";
     }
    public int max(int a , int b){
        return a>b?a:b;
    }
}

构造器

package com.gentlesoft.oa.archives.controller;
public class Person {
    // 一个类即使什么都不写，他也会存在一个方法
    // 显示定义的构造器
    String name ;
    // 实例化初始值
    //1.使用new 关键字，实质是调用构造器
    //2.用来初始化值
    public Person(){
        //this.name = "张三";
    }
    // 有参构造  定义了有参构造，无参构造就必须显示定义
    public Person(String name){
        this.name = name;
    }
    // Alt + insert  会生成构造器快捷键
    /**
     * 构造器：
     * 1.和类名相同
     * 2.没有返回值
     作用：
        1.new 本质是调用构造方法
        2.初始化对象的值
     注意点：
        1.定义构造器之前，如果是无参构造，无参构造就必须显示定义
     */
}

封装

属性私有，get/set

调用
    package com.gentlesoft.oa.archives.controller;
​
public class test {
    public static void main(String[] args) {
        Person p = new Person();
        p.setAge(18);
        p.setName("张三");
        System.out.println(p.getAge());
        System.out.println(p.getName());
        p.setAge(999);// 不合法的数据
        System.out.println(p.getAge());
​
    }
}
​
## 设置封装方法
    package com.gentlesoft.oa.archives.controller;
public class Person {
    // 属性私有
   private String name ;
   private int age; // 年龄
   private char sex; //性别
   private int id; // 学号
​
    // 提供一些public 的get、set方法
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        if(age<0||age>100){
            this.age=3;
        }else {
            this.age = age;
        }
    }
​
    public char getSex() {
        return sex;
    }
​
    public void setSex(char sex) {
        this.sex = sex;
    }
​
    public int getId() {
        return id;
    }
​
    public void setId(int id) {
        this.id = id;
    }
}
​

继承 extends

只能单继承

image-20220628102005947

super 调用父类的方法

private 私有的无法被继承

image-20220628102925723

重写

需要有继承关系，子类重新父类的方法

  1. 方法名必须相同

  2. 参数列表必须相同

  3. 修饰符：范围可以扩大但不能缩写：public>protected>default>private

  4. 抛出的异常：范围，可以被缩小但不能扩大；

多态

image-20220628151242305

 

posted @ 2022-06-28 16:31  重新study谭大叔  阅读(82)  评论(0)    收藏  举报