Java入门基础整理(一)

hello

执行 javac Hello.java 生成 Hello.class

// Hello 要与文件名相同
public class Hello{
    // 程序执行的起点
    public static void main(String[] args){
        System.out.print("Hello world");
    }
}

数据类型

1.基本类型
    整数型 byte short  int long
    浮点型float double
    字符 char
    布尔boolean
2.引用数据类型
字符串 数组 类 接口

关键字/标识符/常量

关键字

标识符
    不使用数字开头 

常量 
    字符串常量   双引号   'aaaaa'
    整数常量
    浮点数常量
    字符常量  单引号引起来的 只能有一个  'a'   'b'
    布尔常量  true false
    空常量  null

变量

• 变量名称不能重复
• float和long类型变量 F L 不能丢
• byte short 数值不能超过范围
• 没有赋值的变量不能直接使用
• 变量使用不能超过作用域范围

 public class Bianliang{
  public static void main(String[] args) {
      int num1,num2;
     //  int num1=1,num2=2;
      num1 =10;
      num2 = num1 +10;
      System.out.println(num2);

      System.out.println("-----------");

      byte num3 = 30;
      System.out.println(num3);
      short num4 = 10;
      System.out.println(num4);
      long num5 = 20000;
      System.out.println(num5);

      float num6 = 2.5F;
      System.out.println(num6);

      double num7 = 2.5F;
      System.out.println(num7);

      char zf1 = 'A';
      System.out.println(zf1);

      boolean var1 =true;
      System.out.println(var1);
  }
}

类型

自动转换

• 从小->大

强制转换

int num=(int)100L;
(要转换的类型)范围大的数据

• 注意:
  强制使用不推荐使用

运算符

加减乘除取余
+
-
*
/
%

自增自减
++   --

赋值运算符
=
+=
-=
*=
/=
%=

比较运算符
==
<
>
<=
> =
! =

逻辑运算符
&& 与
|| 或
!  非

三元运算符
数据类型 变量名称=条件判断?表达式a:表达式b

方法

public static void 方法名称(){

}

public class Fangfa{
    public static void main(String[] args) {
        //调用方法
        farmer();
    }
    // 定义方法
    public static void farmer(){
        System.out.println("111");
        System.out.println("222");
        System.out.println("333");
    }
    public static void coo(){
        System.out.println("cook");
        System.out.println("321");
        System.out.println("123");
    }
}

流程(if/switch/for/while)

if(表达式){
}else{
}

if(表达式){
}else if(表达式){
}else{
}

switch(表达式){
    case 常量值:
        语句体;
        break;
    default:
        语句体;
        break;
}

for(;;){
}

while(条件判断){
}

do{
}while(条件判断);

方法调用

方法调用:

1. 单独调用
2. 打印调用
3. 赋值调用

重载

    名称相同,
        1. 参数列表不同
        2. 参数类型不同

public class Fangfa0111{
    public static void main(String[] args) {
        int a=1;
        int b=2;
        System.out.println("-----");
        System.out.println(summ(a, b));//两数相加
        System.out.println(sum_lian(100));//1-某数的之和
        get_num_hello(5);
    }

    public static int summ(int a,int b){
        int c = a+b;
        return c;
    }
    public static int sum_lian(int a){
        int c=0;
        for(int i=0;i<=a;i++){
            c = c+i;
        }
        return c;
    }
    public static void get_num_hello(int a){
        for(int i=1;i<=a;i++){
            System.out.println("Hello");//1-某数的之和
        }
    }


    // 重载(名称相同,参数列表不同)
    public static int cz_sum(int a,int b){
        int c = a+b;
        return c;
    }
    public static int cz_sum(int a,int b,int c){
        int dd = a+b+c;
        return dd;
    }
    public static int cz_sum(int a,int b,int c,int d){
        int dd = a+b+c+d;
        return dd;
    }

}

数组arr

1. 是一种引用数据类型
2. 数组中的多个数据,类型必须统一
3. 数组长度不可改变

初始化

1. 动态初始化(指定长度)
2. 静态初始化(指定内容)

数据类型[] 数组名称 = new 数据类型[数据长度]

public class Arr{
    public static void main(String[] args) {
    
        // 动态初始化
        int[] arrayA = new int[300];
        double[] arrayB = new double[10];
        String[] arrayC = new String[5];
        //静态初始化
        int[] arrayD = new int[] {1,2,4,5,6,7};
        int[] arrayE = {1,2,4,5,6,7};
        //读取
        System.out.println(arrayE[1]);
        //赋值
        arrayA[1] = 50;
        System.out.println(arrayA[5]);//默认0  ''  0.0
        System.out.println(arrayA[1]);//50
        //获取长度
        System.out.println(arrayD.length);
        //数组遍历
        for(int i=0;i<=arrayD.length;i++){
            System.out.println(arrayD[i]);
        }
        //数组的最值
        //数组反转(使用第三方)
    }
    public static void get_sum(int[] arrayA){

    }
}

object

导入包
import 包名称.类名称
如果同目录下不用写
Student stu = new Student()
stu.a
stu.a()

public class Obj{
    public static void main(String[] args) {
        int[] arrayD = new int[] {1,2,4,5,6,7};
        // System.out.println(arrayD.toString());
        Student stu = new Student();
        stu.aa();
        System.out.println(stu.bb);
    }
}

random

random 随机数
int r = rand.nextInt();随机生成正负
int r2 = rand.nextInt(10);//0-9

public class Random1{
    public static void main(String[] args) {
        
        // 生成随机数()
        Random rand = new Random();
        int r = rand.nextInt();
        System.out.println("随机数是:"+r);
        int r2 = rand.nextInt(10);
        System.out.println("随机数是:"+r2);//0-9
    }
}

scanner

键盘输入

1.导包
import
2.创建

3.使用

import java.util.Scanner;
public class Scann{
    public static void main(String[] args) {
        String str = "dsds";

        //创建
        Scanner sc = new Scanner(System.in);

        //使用
        //获取键盘输入数据
        // int num = sc.nextInt();
        // System.out.println(num);


        //求两个数的和
        System.out.print("请输入num1:");
        int num1 = sc.nextInt();
        System.out.print("请输入num2:");
        int num2 = sc.nextInt();
        int c = num1+num2;
        System.out.println(c);
    }
}

arraylist idea

import zf.com.Student;
import  java.util.ArrayList;
/**
 arraylist 使用
 1. 自定义学生类
 2. 创建集合 ,用来存学生对象
 3. 根据类创建4个学生对象
 4.将4个学生对象加到  add
 5.遍历集合 for size  get
 */
public class Arraylist_demo {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<Student> ();

        Student one = new Student("a",20);
        Student two = new Student("b",22);
        Student three = new Student("c",24);
        Student four = new Student("d",25);

        list.add(one);
        list.add(two);
        list.add(three);
        list.add(four);

        for (int i = 0; i < list.size(); i++){

            Student stu = list.get(i);
            System.out.println("姓名:"+stu.getName()+",年龄:"+stu.getAge());
        }
    }
}

import  java.util.ArrayList;

/**
Arraylist

 System.out.println(list);//[aa, bb, cc]
 printList(list);//{aa@bb@cc}

 */

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

        ArrayList<String> list = new ArrayList<String> ();

        list.add("aa");
        list.add("bb");
        list.add("cc");
        System.out.println(list);//[aa, bb, cc]

        printList(list);//{aa@bb@cc}
    }
    /**
     定义方法三要素
     1.返回值名称
     2.方法名称
     参数列表
     */
    public static void printList(ArrayList<String> list){
        System.out.print("{");
        for (int i = 0; i < list.size(); i++){
            String name = list.get(i);
            if(i==list.size()-1){
                System.out.print(name);
                System.out.print("}");
                break;
            }
            System.out.print(name+"@");
        }
    }

}

import  java.util.Random;
import  java.util.ArrayList;
/**
一个大集合存入20个随机数字,筛选其中偶数元素,
 放入小集合中

 */

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

        ArrayList<Integer> list = new ArrayList<Integer> ();
        Random r = new Random();
        for (int i = 0; i < 20; i++) {
            list.add(r.nextInt(100+1));
        }

        ArrayList<Integer> smallList = getsmalllist(list);
        System.out.println(smallList);
        System.out.println(smallList.size());

    }

    /**
     * 接受大集合,返回小集合
     */
    public static ArrayList<Integer> getsmalllist(ArrayList<Integer> biglist){
        ArrayList<Integer> smalllist = new ArrayList<Integer> ();
        for (int i = 0; i < biglist.size(); i++) {
            int num = biglist.get(i);
            if (num %2==0){
                smalllist.add(num);
            }
        }

        return smalllist;
    }
}

import zf.com.Person;

import java.util.ArrayList;

/**
定义一个数组,用来存储3个Person对象

 数组缺点:一旦创建,长度不可改变

 ArrayList 集合
 ArrayList<Integer> list = new ArrayList<Integer> ();
    <> 泛型  定义数据的类型
    长度可随意改变
    ArrayList 打印,直接是值
    向集合中加数据 .add
    获取数据      .get
    删除          .remove
    获取长度        .size()

 */
public class Arraylist_person {
    public static void main(String[] args) {
        Person[] array = new Person[3];

        Person one = new Person("'迪丽热巴'",18);
        Person two = new Person("'鹿晗'",23);
        Person three = new Person("'陈赫'",22);

        array[0] = one;
        array[1] = two;
        array[2] = three;

        System.out.println(array[0]);//地址值
        System.out.println(array[1]);
        System.out.println(array[2]);

        System.out.println(array[0].getName());//'迪丽热巴'

        ArrayList<String> list2 = new ArrayList<> ();
        list2.add("aa");
        list2.add("bb");
        list2.add("cc");
        System.out.println(list2);
    }
}

import java.util.Scanner;

/**
 输入一个字符串,统计各种字符串出现的次数
 1. 输入Scanner
 2.键盘输入的字符串   String str = sc.next()
 3.定义四个变量,用来代表各种字符穿心的次数
 4.对字符串一个个进行检查 String->char[]  方法: toCharArray()
 5.遍历char[] 进行判断
 6.打印出现的次数
 */
public class Scanner_test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入一个字符串");
        String input = sc.next();
        int dx = 0;
        int xx = 0;
        int sz = 0;
        int qt = 0;

        char[] charArray= input.toCharArray();
        for (int i = 0; i <charArray.length; i++ ){
            char c =charArray[i];
            if ('A'<=c && c<='Z' ){
                dx++;
            }else if ('a'<=c && c<='z'){
                xx++;
            }else if ('0'<=c && c<='9'){
                sz++;
            }else {
                qt++;
            }
        }
        System.out.println("大写字母有:"+dx);
        System.out.println("小写字母有:"+xx);
        System.out.println("数字有:"+sz);
        System.out.println("其他有:"+qt);

    }


}

static

import zf.com.Static_t;

import java.util.Arrays;

/**
 * Arrays工具类
 Arrays.sort(arr1);  排序
 toString(数组)   数组->字符
 sort               排序 (小到大)

 */
public class Static_demo {
    public static void main(String[] args) {
        Static_t a = new Static_t();
        Static_t b = new Static_t();

        String str = "sdijsncdkncksdmco324";
        char[] arr1 = str.toCharArray();
        Arrays.sort(arr1);
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);
        }
    }
}

string

/**
String字符串类
 equals 比较
 equalsIgnoreCase  比较  忽略大小写

 length 长度
 concat 拼接字符串相当于+

 charAt 获取指定索引位置的单字符
 indexof   字符串首次出现的位置
 substring       截取

 tocharArray()  字符串改为字节数组
 getBytes()     当前字符串底层的字节数组
 replace        替换

 split          切割 字符串->数组
                数组->字符串

 */

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

        String a = "Hello";
        String b = "Hello";
        String c = "hello";
        String d = "hello,asasakndsknd,k4ji2o3n435no4n532o532";
        System.out.println(a.equals(b));//true
        System.out.println(a.equals(c));//false
        System.out.println(a.equalsIgnoreCase(c));//true 忽略大小写
        System.out.println(a.length());

        System.out.println(a.concat("'aaaa'"));//Hello'aaaa'
        System.out.println(a.charAt(2));//l
        System.out.println(a.indexOf("o"));//4
        System.out.println(d.substring(5));// asasakndskndk4ji2o3n435no4n532o532
        System.out.println(d.substring(5,10));// asas

//        cahr[] aa = d.toCharArray();
        String dd =  d.replace("hello","mc");
        System.out.println(dd);

        System.out.println("-----");
        String[] arr1 = d.split(",");
        System.out.println(arr1.length);
        System.out.println(arr1[1]);
    }
}

面向对象

面向对象
封装/继承/多态
继承

1. 单继承
2. 多级继承

public class Demo {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.show();
        zi.method();
    }
}

继承

public class Zi  extends Fu{
    int num = 20;

    //重写方法
    @Override
    public void method() {
        super.method();//调用父类的
        System.out.println("子类方法");
    }

    public void show() {
        int num = 30;
        System.out.println(num);//30 当前
        System.out.println(this.num);//20 子类的
        System.out.println(super.num);//10  父类的
    }

}

Math

Math.abs(double num) 取绝对值
.ceil 向上取整
.floor 向下取整(抹零)
.round 四舍五入
PI 圆周率

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


        double min =-10.8;
        double max =5.9;
        for (int i = (int) min ; i <  max; i++) {
            int abs = Math.abs(i);
            if (abs > 6 || abs < 2.1){
                System.out.println(i);
            }
        }


    }
}

抽象方法

抽象方法
abstract

抽象类和方法的使用

1. 不能直接创建new抽象对象
2. 必须用一个子类继承父类抽象父类
   3.子类覆盖重写父类当中的抽象方法 去掉abstract关键字
3. 创建子类对象进行使用

final 最后赋值

public abstract class Chouxiang {

    //抽象方法
    public abstract void eat();


}

public > protected > default > private