Java知识大全(1+X java)（完结）

• 第一章
• 第二章
• 第三章
• 第四章
• 多态

1.负责解释并执行字节码的是 （JVM）

2.Java 虚拟机的英文简称是（JVM ）

3.Java 字节码文件的后缀为（.class ）

4.Java 虚拟机的英文简称是（JVM ）

5.在 Java 中被视为正确的注释（ ）

6.关于环境变量 PATH，说法正确的有（ 其作用是在命令行执行命令时为系统指明程序所在的路径）

7.Java 1990年由sun microsystems开发的内部项目，1994年改名为java，1995年公开发行，是高级编程语言.

sun 2009年被Oracle收购

J2SE 基础版
J2Me  移动版
J2EE  企业版 大型系统

java是跨平台语言，能跨平台的原因是因为有很多个JVM用于翻译

jvm：java虚拟机
jre：jvm+核心类库  只能运行Java，不能开发
jdk：jre+运行环境   又能运行Java，又能开发

8./t为制表符 （补满8位，满8位补满下一个8位）
有的是4位

如果在.java文件中有汉字，并且报错，就将文件编码改为ANSI码
java的默认字符集编码是Unicode

1.在 Java 语言中，利用 final 关键字来定义 Java 常量，其本质为值不可变的变量。 如果试图改变，则编译错误

2.需要先在程序的第一行加入了代码import java.util.Scanner;，引入 Scanner 工具类，通过该工具类从控制台获取输入。

3.Scanner input = new Scanner(System.in);
        System.out.print("请输入Java工程师底薪：");
        //从控制台获取输入—底薪，赋值给basSalary
        basSalary = input.nextInt();
input.nextxxx ：接受各种类型
next和nextLine的区别：next不接受空格回车 nextLine接受

4.Java中 float声明中必须在末尾加f，因为小数默认是double

5.变量存于内存中

6.public class LanQiao {
public static void main(String[] args) {
char c='a';
System.out.println(c+1) ;
}
}
请问程序执行的输出结果是什么（ 98）

7.input.nextxxx ：接受各种类型
next和nextLine的区别：next不接受空格回车 nextLine接受

8.任何类型遇到字符串，转为字符串，char 
9.字符串判断相等用equals
 
10.%的正负问题，永远与被除数一致
 
8.Java 虚拟机的英文简称是（JVM ）
 
9.Math.random（）； 随机数【0,1），double类型
三位随机整数：强转int，*900+100  四位数：*9000+1000
 
10.数组创建：数据类型[] 数组名 = new 数据类型[数组长度];
 
11.for(数据类型 变量名 : 数组或集合){
    循环代码块
}
//对数组或集合进行遍历
 
12.冒泡排序：冒泡排序的核心就是依次比较相邻的两个数，升序排序时将小数放在前面，大数放在后面。
第一轮之后，最大的数被放在了最后面。
for(int i=0;ia[j+1]){
            temp=a[j];
            a[j]=a[j+1];
            a[j+1]=temp;
        }
 
13.在Arrays的方法中的Arrays.sort()排序中，默认为从小到大的排序，如果想用Arrays.sort()从大到小的顺序排列，则需要用到Comparator比较器接口；

实现java.util.Comparator;
 
14.字符串
String stuName1 = new String("王云");
char[] charArray = {'刘','静','涛'};
String stuName2 = new String(charArray);
String stuName3 = new String(charArray,1,2);//从'静'字开始，截取 2 个字符，结果是“静涛”




String s1 = "您好";
        s1 = s1 + ",蒋老师!";//创建一个新字符串用来连接两个字符串，并让s1指向这个新字符串





        String s1 = "blue bridge";
        String s2 = "Blue Bridge";
        System.out.println(s1.charAt(1));            //查找第2个字符，结果为l
        System.out.println(s1.length());            //求s1的长度，结果为11
        System.out.println(s1.indexOf("bridge"));    //查找bridge字符串在s1中的位置，结果为5
        System.out.println(s1.indexOf("Bridge"));    //查找Bridge字符串在s1中的位置
        System.out.println(s1.equals(s2));            //区分大小写比较，返回false
        System.out.println(s1.equalsIgnoreCase(s2));    //不区分大小写比较，返回true

        String s = "我是学生，我在学java!";
        String str = s.replace('我', '你');            //把"我"替换成"你"
        System.out.println(str);
    }
    



 String fileName = "20200801柳海龙Resume.docx";
    System.out.println(fileName.startsWith("2014"));    //判断字符串是否以"2014"开头
    System.out.println(fileName.endsWith("docx"));    //判断字符串是否以"docx"结尾
    System.out.println(fileName.endsWith("doc"));    //判断字符串是否以"doc"结尾
    System.out.println(fileName.toLowerCase());        //将大写变为小写
    System.out.println(fileName.toUpperCase());        //将小写变为大写
    System.out.println(fileName.substring(8));        //从第9个位置开始到结尾截取字符串
    System.out.println(fileName.substring(8, 11));        //从第9个位置开始到第11个位置结尾截取
    //字符串
    String fileName2 = "  20200801柳海龙Resume  .docx ";
    System.out.println(fileName2.trim());            //忽略原字符串两端的空格






 System.out.println("创建StringBuffer对象");
        //使用StringBuffer()构造器创建对象
        StringBuffer strB1 = new StringBuffer();
        System.out.println("new StringBuffer()创建对象的长度为：" + strB1.length());
        //使用StringBuffer(String str)构造器创建对象
        StringBuffer strB2 = new StringBuffer("柳海龙");
        System.out.println("new StringBuffer("柳海龙")创建对象的长度为：" + strB2.length());
        System.out.println("strB2里的内容为：" + strB2);
        //使用append、insert方法追加、插入字符串
        System.out.println("使用append方法追加字符串");
        strB2.append("，您好！");        //在最后增加"，您好！"'
        System.out.println(strB2);
        strB2.insert(3,"工程师");        //从第4个位置开始，插入"工程师"
        System.out.println(strB2);
    }



String 可以使用“==”进行比较，但 StringBuffer 不行，因此不能使用 “==” 对 StringBuffer 进行比较。

 
package baobao;
import java.util.Locale;
import java.util.Scanner;
import java.util.Arrays;

public class snasan {

    public static void main(String[] args) {
        String textequals = new String("Hello world");//不区分大小写
        String textequalsTwo = new String("Hello World");
        if(textequals.equalsIgnoreCase(textequalsTwo)){
            System.out.println("true");
        }
        else System.out.println("flase");


        String textequals = new String("Hello world");
        String textTow = textequals.toUpperCase();//大写
        String textTow = textequals.toLowerCase();//小写
        System.out.println(textTow);
    }


        String textequals = new String("Hello world");//indexOf判断字符串A是否存在字符串B中，存在则返回位置，不存在返回-1
        int weizhi = textequals.indexOf("W");
        System.out.println(weizhi);





        String textequals = new String("      Hello world");//trim去掉首尾巴空格
        System.out.println(textequals.trim());





        String textequals = new String("Hello world");//截取字符串：substring（start，end）//左闭右开区间
        int start = 0;
        int endd = textequals.indexOf(" ");
        String jqzfb = textequals.substring(start,endd);//
        int end = textequals.indexOf(" ");
        String jqzfc = textequals.substring(end);//
        System.out.println(jqzfb + jqzfc);





        String phone = "0123-123456";//split拆分字符串
        String[] ps = phone.split("1");
        for(String pss : ps){
            System.out.println(pss);
        }
    }
}

 
15.如果对字符串进行频繁修改，使用StringBuffer类
 
16.String产生常量池对象，栈引用，堆对象。创建String如果之前不存在则在产生常量池对象、堆对象、栈引用。如果之前存在则产生堆对象，栈引用
 
17.split拆分字符串会有很多特殊符号不给用，解决方法有两个：
1.在String phone = "0123|123456";
        String[] ps = phone.split("//|");加两个//就可以了
2.String phone = "0123|123456";
  StringTokenizer token = new StringTokenizer（phone，“|”）；
   while（token.hasMoreElement（））{
                System.out.println(token.nextElement);；
   }
 
18.根据位置找字符：charAt
替换字符：replace（old，new）
StringBuffer的追加：append；插入：insert（位置数字，插入内容）
逆序：reverse（）；String转StringBuffer：StringBuffer sb = new StringBuffer（s）；

 
第三章 
1.封装：public class Student {
    private int stuAge ;

    //获取stuAge的值
    public int getStuAge() {
        return stuAge;
    }

    //给stuAge赋一个合法的值
    public void setStuAge(int age) {
        //如果年龄在合理范围内，则正常赋值
        if( age >0 && age <110)
            stuAge = age;
        else //如果对年龄的赋值不合理，则设置为默认值0
            age = 0 ;
    }
}
 
2.this构造用法：public class Student1{
    private String  name;
    private int age;
    private int sex;
    private int grade;

    //构造方法，用户初始化对象的属性
    public Student1(String name,int age,int sex,int grade){
        //调用Student类中得另一个构造方法
        this(name,age,sex);
        this.grade=4;
    }
    //构造方法，用户初始化对象的属性（不带年级参数，设置年级默认值为4）
    public Student1(String name, int age, int sex) {
       this(name,sex);
        this.age = age;
       this.grade = 4;
    }

    //构造方法，用户初始化对象的属性
    //不带年龄、年级参数，设置年龄默认值为22，年级默认值为4
    public Student1(String name, int sex) {
       this.sex = sex;
        this.name = name;
        this.age = 22;
        this.grade = 4;
    }

    public Student1(String name) {
        this.name = name;
        this.age = 22;
        this.grade = 4;
    }

    public void setSex(int sex) {

        this.sex = sex ;
    }

    public int getGrade() {
        return grade;
    }


    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
      if( age >0 && age <110)
            this.age = age;
        else
            this.age = 0 ;
    }
    //定义听课的方法，在控制台直接输出
    public void learn() {
        System.out.println(name + "正在认真听课！");
    }

    //定义写作业的方法，输入时间，返回字符串
    public String doHomework(int hour) {
        return "现在是北京时间:" + hour + "点，" + name + " 正在写作业！";
    }


}
 
3.static 加上是静态，不加是非静态
同一个类中，有static的不能直接调用没有static的方法
不在同一个类中，调用方法必须是静态的
 
4.方法重载：方法名相同，参数列表不同。（与返回值无关，与参数名无关）
 
5.方法重写：子 extends 父
 
6.private set//设置 get//取
 
7.this的用法：当成员变量和局部变量重名时，在方法中使用this时，表示的是该方法所在类中的成员变量；
 
8.date直接返回当前时间
Date date = new Date;
date -》String：
SimpleDateFormat  sdf= new SimpleDateFormat("yyyy-MM-dd");
String datesdt = sdf.format(date)
 
9.图书管理系统
 
package com.tushu;

public class TextBook {
    public static void main(String[] args) {
        BookManager manager = new BookManager();
        manager.init();
        manager.menu();
    }
}

 
package com.tushu;

import java.util.Date;

public class Book {
    private int id;
    private String name;
    private int state;//状态 被借 在库
    private Date borrowdate;
    private int borrowcount;

    public int getBorrowcount() {
        return borrowcount;
    }

    public void setBorrowcount(int borrowcount) {
        this.borrowcount = borrowcount;
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public int getState() {
        return state;
    }

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

    public void setState(int state) {
        this.state = state;
    }

    public void setBorrowdate(Date borrowdate) {
        this.borrowdate = borrowdate;
    }

    public Date getBorrowdate() {
        return borrowdate;
    }
}

 
package com.tushu;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

import static javax.print.attribute.Size2DSyntax.MM;

public class BookManager {
    private Book[] books ;
    private Scanner input = new Scanner(System.in);
    public void init(){//初始化
        books = new Book[10];
        Book book01 = new Book();
        book01.setName("一本书");
        book01.setId(1000);
        book01.setBorrowcount(0);
        book01.setState(1);//在库

        Book book02 = new Book();
        book02.setName("er本书");
        book02.setId(1001);
        book02.setBorrowcount(0);
        book02.setState(1);//在库

        Book book03 = new Book();
        book03.setName("san本书");
        book03.setId(1002);
        book03.setBorrowcount(0);
        book03.setState(1);//在库

        books[0] = book01;
        books[1] = book02;
        books[2] = book03;
    }

    public void menu(){
        System.out.println("=============欢迎进入图书管理系统=============");
        System.out.println("请根据提示选择：");
        System.out.println("1.增加图书");
        System.out.println("2.删除图书");
        System.out.println("3.借阅图书");
        System.out.println("4.归还图书");
        System.out.println("5.图书风云榜");
        System.out.println("6.查看所有图书");
        System.out.println("==========================================");
        int chose = input.nextInt();
        switch (chose){
            case 1:
                addbooks();
                break;
            case 2:
                deletebooks();
                break;
            case 3:
                borrowbooks();
                break;
            case 4:
                returnbooks();
                break;
            case 5:
                bookrank();
                break;
            case 6:
                showbooks();
                break;
            default:
        }
    }
    public void isContinueMenu(){
        System.out.println("是否进行其他操作？（按y继续/按其他结束）");
        String isContinue = input.next();
        if (isContinue.equals("y")){
            menu();
        }
    }

    public void addbooks(){
        System.out.println("增加图书");
        Book book = new Book();
        System.out.println("请输入书的编号：");
        int id = input.nextInt();
        System.out.println("请输入书的名字：");
        String name = input.next();
        int state = 1;
        book.setId(id);
        book.setName(name);
        book.setState(state);

        int position = -1;
        for(int i=0;i 
第四章 
在类中继承父类：extends
 
子类重写父类，如果想继续用父类，使用super.
 
构造方法无返回值
public 类名 //严格规定，类叫什么，这个类名就叫什么
含参数构造方法，可以一次性赋多个值
构造方法之间想通过方法名调用需要用this.
 
方法标签相同，方法体不同 用抽象方法 abstract
public abstract void print（）//抽象方法
抽象方法必须在抽象类中
 
final修饰的类 无敌，不能改
 
多态
父类 引用对象名 = new 子类
 
8.Java 虚拟机的英文简称是（JVM）
 
8.Java 虚拟机的英文简称是（JVM）
 
package com.abcd;

public class Text {//斐波那契数组记忆化递归
    public static void main(String[] args) {
        digui a = new digui();
        int sum;
        int[] aa = new int[1000000];
        sum = a.Dg(aa,6);
        System.out.println(sum);

    }
}
class digui{

    public int Dg(int[] aa,int a){

        if(a==1)return 0;
        if(a==2)return 1;
        if(aa[a]!=0){
            return aa[a];
        }
        else {
            aa[a] = Dg(aa,a-1)+Dg(aa,a-2);
            return aa[a];
        }
    }
}

 
多态 
当父类的方法，子类调用出现歧义并且为了代码的方便时，使用多态。

多态是同一个行为具有不同表现形式或形态的能力，多态性是对象多种表现形式和体现。

多态的前提：
子父类的继承关系或子类实现父类接口
必须有方法的重写
父类引用指向子类对象

多态成员变量：变量不像方法有重写，所以直接执行父类，父类没有这个变量则报错
多态成员方法：方法可重写，执行子类方法，父类没有这个方法则报错
 
多态一般使用步骤：
1.写出父类方法
2.重写父类方法
3.运行，运行类中 父类 引用对象名 = new 子类称为使用多态
 
多态的实现：
1.方法重写
2.方法重载
3.使用父类作为方法的传值
4.使用父类作为方法的返回值（public static 父类名 名字（int 名字））