java-知识点

简介

java是面向对象、跨平台的高级程序设计语言
示例：新建一个.java文件，并在文件中写入
public class HelloWord {
public static void main(String[] args) {
System.out.println(“Hello World”)
}
}

编译

javac HelloWord.java ： 可将java源文件编译为class字节码文件。
编译成功后，会出现HelloWord.class的文件。

运行

java HelloWord

主方法入口

所有java程序由public static void main(String [] args) 方法开始执行

数据类型

java的数据类型分为基本数据类型和引用数据类型。
基本数据类型有byte|short | int | long | float | double | boolean | char

boolean

1位 true 和false ，默认是false

byte

1bit 8位 有符号的数据类型，默认是0。最小-128，最大127

char

16位 单一的unicode字符

Short

16位 有符号的数据类型，默认是0。

Int

32位 有符号的数据类型，默认是0。

Float

32位 单精度数据类型，默认是0.0f。
定义float类型时必须在数字后面跟上F或者f

Long

64位 有符号的数据类型，默认是0。

double

64位 双精度数据类型，默认是0.0f。

void

对应的包装类是java.lang.Void,我们无法直接操作

包装类

在实际开发中我们经常需要使用对象，而不是内置数据类型。为此java语言为内置数据类型提供了包装类。

Number类

java为每种基本数据类型都提供了对应的包装类（Integer、Long、Byte、Double、Float、Short）。所有的包装类都是抽象类Number 的子类。
这种由编译器特别支持的包装称为装箱。
当内置数据类型被当作对象使用的时候，编译器会把内置类型装箱为包装类。相似的，编译器也可以把一个对象拆箱为内置类型。
Number 类属于 java.lang 包。

public class HelloWord {

    public static void main(String[] args) {
        Integer x = 5;
        x = x+10;
        System.out.println(x);

    }
}

Character 类

1、Character类用于对单个字符进行操作；
2、Character类在对象中包装一个基本类型char的值。

public class HelloWord {

    public static void main(String[] args) {
        //创建Character类对象
        Character ch = new Character('c');
        // 是否是一个字母
        System.out.println(Character.isLetter('c'));
//        返回指定字母的大写形式
        System.out.println(Character.toUpperCase('c'));
//        判断是否是一个数字字符
        System.out.println(Character.isDigit('c'));
//        返回字符串形式，字符串的长度为1
        System.out.println(Character.toString('c'));
    }
}

引用数据类型

在java中引用类型的变量类似于c/c++的指针。引用类型指向一个对象。
对象和数组都是引用数据类型
引用类型的默认值都是null

数组

1、数组是存储在堆上的对象，可以保存多个同类型的变量。
2、数组是一种数据结构。
3、java中的数组是用来存储固定大小的同类型数据。
4、数组声明：
int [] myList;
5、创建数组：
myList = new int[5];
另外，还可以使用如下的方式创建数组。
dataType[] arrayRefVar = {value0, value1, …, valuek};
6、数组元素是通过索引访问的，数组索引从0开始到myList.length-1
7、示例：

public class HelloWord {

    public static void sysOut(String args){
        System.out.println(args);
    }

    public static void main(String[] args) {
        String[] myList = new String[3];
        myList[0] ="yang";
        myList[1] = "song";
        myList[2] = "yang";
        for (int i=0; i<myList.length; i++) {
            sysOut(myList[i]);
        }
    }
}

8、For-Each 循环
数组的类型和大小都是确定的，可以使用for-each循环。

public class HelloWord {

    public static void sysOut(String args){
        System.out.println(args);
    }

    public static void main(String[] args) {
        String[] myList = new String[3];
        myList[0] ="yang";
        myList[1] = "song";
        myList[2] = "yang";
        for (String i:myList){
            sysOut(i);
        }
    }
}

字符串

1、在java中字符串属于对象。
2、java提供了String类来创建和操作字符串。
3、使用关键字或者构造器创建字符串。

public class HelloWord {

    public static void main(String[] args) {
//        使用关键字创建字符串
        String greeting = "菜鸟";
//        使用构造方法创建字符串
        String Reet = new String("菜鸟1");
    }
}

4、获取字符串长度

String site = "www.runoob.com";
int len = site.length();

5、连接字符串,常使用+，也可以使用concat()方法。

String a = "菜鸟b";
String b = "菜鸟c";
System.out.println(a +"+"+b);
System.out.println(a.concat(b));

6、字符串格式化

public class HelloWord {

    public static void main(String[] args) {
        float floatVar = 2f;
        int intVar = 2;
        String fs = String.format("浮点型变量的值为"+"%f,整型变量的值为" +
                "%d", floatVar, intVar);
        System.out.println(fs);
    }
}
 

7、字符串常用方法

public class HelloWord {

    public static void main(String[] args) {
        String s = "asdfa";
        String s2 = "adf";
//        返回指定索引处的char值
        System.out.println(s.charAt(2));
//        返回指定字符或者字符串在字符串中第一次出现的索引
        System.out.println(s.indexOf("f"));
        //        返回指定字符或者字符串在字符串中最后一次出现的索引
        System.out.println(s.lastIndexOf("f"));
//按ascii码顺序比较，先比较第一个字符，依次类推，返回值是整数。
        System.out.println(s.compareTo(s2));
//        将指定字符串连接到此字符串的结尾
        System.out.println(s.concat(s2));
        System.out.println(s.startsWith("f"));
        System.out.println(s.endsWith("f"));
        System.out.println(s.equals(s2));
        System.out.println(s.equalsIgnoreCase(s2));
//        使用指定的字符集将String编码为byte序列，并将结果存储在一个新的byte数组中
        byte [] b = s.getBytes();
        System.out.println(b.length);
        char[] c = s.toCharArray();
        System.out.println(c);
//        返回字符串的哈希值
        System.out.println(s.hashCode());
//        返回字符串长度
        System.out.println(s.length());
//        将字符串中的所有oldchar替换为newchar
        System.out.println(s.replace("a","b"));
//        根据给定的正则表达式的匹配拆分此字符串，可指定拆分次数
        System.out.println(s.split("f").length);
//        返回子序列
        System.out.println(s.substring(1,2));
        System.out.println(s.toUpperCase());
//        返回字符串的副本，忽视前导空白和尾部空白
        System.out.println(s.trim());
    }
}

StringBuffer 和 StringBuilder 类

使用StringBuffer和StringBuilder类可以对字符串进行修改，且不会产生新的未使用对象。
StringBuilder非线程安全，但是比StringBuffer有速度优势。
StringBuffer是线程安全的，在应用程序有线程安全的情况下必须使用StringBuffer类。

public class HelloWord {

    public static void sysOut(String args){
        System.out.println(args);
    }

    public static void main(String[] args) {
        StringBuffer sBuffer = new StringBuffer("菜鸟教程官网");
        sBuffer.append("www");
        sBuffer.append(".runoob");
        sBuffer.append(".com");
//        反转字符串
        sBuffer.reverse();
        sBuffer.reverse();
//        移除字符
        sBuffer.delete(1,3);
//        在指定位置插入字符串
        sBuffer.insert(1,"sds");
//        将指定位置的字符串替换为指定字符
        sBuffer.replace(1,3,"");
        sysOut(sBuffer.toString());
    }
}

常量

Java中使用final关键字来修饰常量。
常量使用大写字母表示
常量可以被public/private,final和static修饰。
常量初始化后不可再改变
public static final double PI=3.1415

类型转换

类型转换分自动类型转换和强制类型转换。
从大类型转换为小类型就是强制转换
从小类型转换为大类型就是自动转换

访问控制修饰符

修饰符	说明
default	默认修饰符,不使用任何关键字。在同一个包内及同一包内的子孙类可见
public	对所有类可见
protected	对同一包内的类和所有子类可见
private	在同一个类内可见

非访问控制修饰符

final、abstract、static、synchronized

类

类是一个模板，它描述一类对象的行动和状态。
一个源文件中只能由一个public类，且public类的类名必须和源文件同名。一个源文件可以有多个非public类
类名由若干个单词组成，每个单词的首字母都应该大写。（大驼峰法）
类有外部类、抽象类、final类、内部类、匿名类等
外部类不可声明为private
一个类不能同时被abstract和final修饰。
被final修饰的类不能被继承

对象

对象是类的实例，有状态和行为
Java中使用new关键字来创建一个新对象。
Puppy myPuppy = new Puppy(“tommy”)
通过创建的对象可以访问类中的变量和方法。

接口

接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类。
接口中的方法默认是public
接口中的变量默认是 public static final

抽象类

抽象类不能被用来实例化对象。
如果一个类中包含了抽象方法，那么该类一定是抽象类
抽象类可以包含抽象方法和非抽象方法
抽象类中也可以不包含抽象方法
任何继承抽象类的子类必须实现父类的所有抽象方法，否则还是抽象类。

修饰符对类的影响

项目	外部类	内部类	接口	抽象类	匿名类
public	Y	Y	Y	Y
default	Y	Y	Y	Y
protected	N	Y	N	N
private	N	Y	N	N
static	N	N	N	N	N
final	Y
abstract	Y	~	~	~
synchronized

方法

1、说明：方法就是行为。一个类可以有很多方法。
2：命名：方法名由若干个单词组成，首个单词以小写字母开头，后面的每个单词首字母都大写（小驼峰法）
3、常见方法：抽象方法、类方法（静态方法）、匿名方法、构造方法、成员方法
被final修饰的方法不可被重写
synchronized关键字声明的方法同一时间只能被一个线程访问。

构造方法

每个类都有构造方法。
如果没有显式定义构造方法，java编译器会为该类提供一个默认的构造方法
在创建对象时，至少要调用一个构造方法。
构造方法的名称必须和类同名，
一个类可以有多个构造方法

public class Puppy{
	public Puppy(){
	}
	public Puppy(String name) {
	}
}

抽象方法

抽象方法不能被声明为final和static
抽象方法的声明：public abstract sample();

静态方法

静态方法不能使用类的非静态变量。
静态方法中只能调用静态方法，不可调用非静态方法。
静态方法从参数列表得到数据，然后计算这些数据。

修饰符对方法的影响

项目	成员方法	静态方法	构造方法	抽象方法
public	Y	Y	Y
default	Y	Y	Y
protected	Y
private	Y	Y	Y
static	Y	~		N
final	Y			N
abstract	Y	N		~
synchronized

变量

在java中，所有变量在使用前必须进行声明
变量就是申请内存来存储值的。当创建变量时，需要在内存中申请空间。内存管理系统跟进变量的类型为变量分配空间，分配的空间只能用来存储该类型数据。
变量分为局部变量、成员变量和类变量（静态变量）
被final修饰的变量不可被修改
被final修饰的实例变量必须显式指定初始值
final和static常被一起使用来指定一个常量

局部变量

在方法、构造方法或者语句块中定义的变量称为局部变量。变量声明和初始化都在方法中，方法结束后，变量会自动销毁。
访问修饰符不能修饰局部变量
局部变量是在栈上分配的
局部变量没有默认值，被声明后必须初始化才可以使用。
示例：
package com.runoob.test;

public class Test{
public void pupAge(){
int age = 0;
age = age + 7;
System.out.println("小狗的年龄是: " + age);
}
}

实例变量(成员变量)

成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。
实例变量在对象创建时被创建，在对象被销毁时销毁。
访问修饰符可以修饰实例变量
实例变量的值可以在声明时指定，也可以在构造方法中指定。

import java.io.*;

public class HelloWord {
    public String name;
    private double salary;
    public HelloWord(String empName){
        name = empName;
    }

    public void setSalary(double empSal){
        salary = empSal;
    }
    
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

类变量

定义在类中，方法体之外，但必须声明为static类型。
类变量也称静态变量。
静态变量被存储在静态存储区。常用来申明常量。
静态变量在第一次被访问时创建，在程序结束时销毁。
静态变量可通过classname.variablename 的方式访问。
无论一个类实例化多少对象，它的静态变量只有一份拷贝。

修饰符对变量的影响

项目	成员变量	静态变量	局部变量
public	Y	Y	N
default	Y	Y	N
protected	Y	Y	N
private	Y	Y	N
static	Y	~	N
final	Y	Y	N
abstract	N	N	N
synchronized	N	N	N

注释

1、单行注释：// 单行注释 或者/单行注释/
2、多行注释：
/*
*多行注释
*/

继承

子类可以继承父类的所有公共方法和变量
父类声明为public的方法，子类中也必须是public
父类中声明为protected的方法，子类中要么是proected,要么是public。不能申明为private
父类中声明为private的方法，不能被继承
Final修饰的类不能被继承。

运算符

算术运算符
关系运算符
位运算符
逻辑运算符
赋值运算符
条件运算符（?:）
instanceof

String name = "James";
boolean result = name instanceof String; 

Math 类

public class HelloWord {
    public static void main(String[] args) {
        System.out.println(Math.min(1,2));
    }
}

for 循环

public class HelloWord {

    public static void main(String[] args) {
        for(int i=0;i<10;i++){
            System.out.println(i);
        }
    }
}

可初始化一个或者多个循环变量；也可以是空语句

public class HelloWord {

    public static void main(String[] args) {
        int i=0;
        for(;;){
            if (i<10){
                System.out.println(i);
                i++;
            }
        }
    }
}

增强for循环

public class HelloWord {

    public static void main(String[] args) {
        int [] numbers = {10,20,30};
        for(int i:numbers){
            System.out.println(i);
        }
    }
}

while循环

public class HelloWord {

    public static void main(String[] args) {
        int x = 10;
        while(x<20){
            x++;
            System.out.println(x);
        }
    }
}

do…while循环

public class HelloWord {

    public static void main(String[] args) {
        int x = 10;
        do {
            x++;
            System.out.println(x);
        } while (x<20);
    }
}

break

break主要用在循环语句或者 switch 语句中，用来跳出整个语句块。
break跳出内层循环

continue

用在循环语句中，表示停止当前循环，开始下一轮循环。

if…else…

public class HelloWord {

    public static void main(String[] args) {
        int x =30;
        if (x<20){
            System.out.println("成功");
        }else if(x<25){
            System.out.println("失败");
        }else{
            System.out.println("OKok");
        }
    }
}

switch…case…

1、switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支
2、switch的变量类型可以是byte、short、int、char、String类型
3、Case后只能跟常量或者字面量。
4、Case语句不必要包含break语句，如果没有break语句出现，程序会继续执行下一条case语句，直到break语句。
5、可以包含一个default分支。default在没有case语句的值和变量值相等的时候执行。default分支不需要break语句。

public class HelloWord {

    public static void main(String[] args) {
        char grade = 'D';
        switch(grade){
            case 'A':
                System.out.println("有效");
                break;
            case 'B':
                System.out.println("一般");
                break;
            case 'C':
                System.out.println("差劲");
                break;
            default:
                System.out.println("未知");
        }

    }
}