【Java】基础知识笔记
1.比特和字节
一个0或者一个1存储为一个比特(bit),是计算机中最小的存储单位
计算机中最基本的存储单元是字节(byte),每个字节由8个比特构成
2.代码注释
(1)单行注释://注释内容
(2)多行注释:/* 注释内容 */
(3)文档注释:/** 注释内容 */
3.自动转型
byte、char、short —>int —>long —>float —>double
byte、char、short三种类型的变量之间做运算时,结果为int型
4.三元运算符
(条件表达式)?表达式1:表达式2(自动类型转换)
//运行结果:9.0
int a = 5;
System.out.println("value is :" + ((a < 5) ? 10.9 : 9));
5.位运算符
(1)与(&)运算符,两个二进制操作数对应位同为1 结果位 才为1,其余情况为0
(2)或(|)运算符,两个二进制操作数对应位只要有一个为1 结果位 就为1,其余情况为0
(3)非(~)运算符,一个二进制操作数,对应位为0,结果位为1;对应位为1,结果位为0
(4)异或(^)运算符,两个二进制操作数对应位相同为0,不同为1
public static void main(String[] args) {
/*
计算机存储、操作的是补码
*/
int a = 15;
int b = 127;
/*
15 原码:0000 1111 反码:0000 1111 补码:0000 1111
127 原码:0111 1111 反码:0111 1111 补码:0111 1111
a&b 0000 1111
a|b 0111 1111
~a 值为-16 计算机存储为:补码 1111 1111 1111 1111 1111 1111 1111 0000
反码 1111 1111 1111 1111 1111 1111 1110 1111 即补码减去1
原码 1000 0000 0000 0000 0000 0000 0001 0000 即-16
a^b 0111 0000
注意:正数左右位移都补0
a>>1 0000 0111
a<<1 0001 1110
*/
System.out.println(a >> 1);
System.out.println(a << 1);
int c = -15;
int d = -127;
/*
-15 原码:1000 0000 0000 0000 0000 0000 0000 1111
反码:1111 1111 1111 1111 1111 1111 1111 0000
补码:1111 1111 1111 1111 1111 1111 1111 0001 即反码加上1
-127 原码:1000 0000 0000 0000 0000 0000 0111 1111
反码:1111 1111 1111 1111 1111 1111 1000 0000
补码:1111 1111 1111 1111 1111 1111 1000 0001
c&d 1111 1111 1111 1111 1111 1111 1000 0001
c|d 1111 1111 1111 1111 1111 1111 1111 0001
~c 0000 0000 0000 0000 0000 0000 0000 1110
c^d 0000 0000 0000 0000 0000 0000 0111 0000
注意:负数向右位移补1,向左位移补0
c>>2 补码:1111 1111 1111 1111 1111 1111 1111 1100
反码:1111 1111 1111 1111 1111 1111 1111 1011
原码:1000 0000 0000 0000 0000 0000 0000 0100
c<<2 补码:1111 1111 1111 1111 1111 1111 1100 0100
反码:1111 1111 1111 1111 1111 1111 1100 0011
原码:1000 0000 0000 0000 0000 0000 0011 1100
*/
System.out.println(c >> 2);
System.out.println(c << 2);
}
6.标识符和关键字
标识符规则:(1)标识符由字母、下划线、$和数字组成;
(2)标识符的第一个字符不能是数字;
(3)标识符不能使用关键字和保留字;
(4)标识符不能是true、false和null;
(5)标识符区分大小写,长度不受限制
关键字:abstract、assert、boolean、break、byte、case、catch、char、calss、const、continue、default、do、
double、else、enum、extends、final、finally、float、for、goto、if、implements、import、instanceof、
int、interface、long、native、new、package、private、protected、public、return、short、static、strictfp、
super、switch、synchronized、this、thow、throws、transient、try、void、volatile、while
7.数据类型
基本数据类型:byte(1个字节)、short(2个字节)、int(4个字节)、long(8个字节)、boolean(true和false)、
char(2个字节)、float(4个字节)、double(8个字节)
引用数据类型:数组、类和接口
8.==运算符
(1)如果比较的是基本数据类型变量:比较两个变量保存的数据是否相等。(不一定类型要相同)
(2)如果比较的是引用数据类型变量:比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
9.switch(表达式)
表达式的值必须是下述几种类型之一:byte,short, char,int,枚举 (jdk 5.0),String (jdk 7.0)
public enum Season {
春季, 夏季, 秋季, 冬季;
}
Season season = Season.春季;
switch (season) {
case 冬季:
System.out.println("隆冬腊月");
break;
case 夏季:
System.out.println("暑假真好");
break;
case 春季:
System.out.println("春天种下种子");
break;
case 秋季:
System.out.println("秋天收获果实");
break;
default:
break;
}
10.进制转换
//十进制转十六、八、二进制
String var1 = Integer.toHexString(110);
String var2 = Integer.toOctalString(110);
String var3 = Integer.toBinaryString(110);
System.out.println(var1);
System.out.println(var2);
System.out.println(var3);
//十六、八、二进制转十进制
Integer var4 = Integer.parseInt("6e", 16);
Integer var5 = Integer.parseInt("156", 8);
Integer var6 = Integer.parseInt("1101110", 2);
System.out.println(var4);
System.out.println(var5);
System.out.println(var6);
11.Scanner获取键盘输入
//输入不匹配异常InputMismatchException
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
int num = scanner.nextInt();
System.out.println(num);
}
12.类
类的组成:属性(成员变量)、方法、构造器、代码块、内部类
成员变量:(1)加载到堆空间中(非static);
(2)有默认初始化值;
(3)定义在类的一对{}内;
(4)可以在声明属性时,指明其权限,使用权限修饰符
局部变量:(1)加载到栈空间;
(2)没有默认初始化值,调用前显式赋值;
(3)定义在方法内、代码块内、构造器内,方法形参、构造器形参;
(4)不可以使用权限修饰符
13.面向对象三大特征
(1)封装性:隐藏对象的属性和实现细节
(2)继承性:子类拥有父类的数据属性和行为,并可以扩展新功能
(3)多态性 :父类的引用指向子类的对象
14.方法重载
重载方法参数必须不同,与返回值无关
(1)参数个数不同,如method(int x)与method(int x,int y)不同
(2)参数类型不同,如method(int x)与method(double x)不同g
(3)参数顺序不同,如method(int x,double y)与method(double x,int y)不同
15.方法重写
(1)方法的重写是指两个方法的返回值、方法名、参数的类型和个数相同(子类重写父类的方法)
(2)如需父类中原有的方法,可使用super关键字,该关键字引用了当前类的父类
public class MethodOverride {
public static void main(String[] args) {
/*
运行结果:
讲话
吃饭
我是学生,会讲话
我是学生,会走路
吃饭
我是学生,会讲话
吃饭
我是学生,会走路
*/
//父类的引用指向父类的对象
Person person = new Person();
person.speak();
person.eat();
//子类的引用指向子类的对象
Student student = new Student();
student.speak();
student.walk();
student.eat();
//父类的引用指向子类的对象
Person var = new Student();
//调用的是子类重写的方法
var.speak();
var.eat();
if (var instanceof Student) {
Student stu = (Student) var;
//子类特有的方法需要向下转型
stu.walk();
}
}
}
class Person {
public void speak() {
System.out.println("讲话");
}
public void eat() {
System.out.println("吃饭");
}
}
class Student extends Person {
@Override
public void speak() {
System.out.println("我是学生,会讲话");
}
@Override
public void eat() {
super.eat();
}
public void walk() {
System.out.println("我是学生,会走路");
}
}
16.this关键字
(1)在本类的成员方法中,访问本类的成员变量
(2)在本类的成员方法中,访问本类的另一个成员方法
(3)在本类的构造方法中,访问本类的另一个构造方法
public class Student {
private String stuName;
private String stuAge;
public Student(String stuName) {
System.out.println("构造方法一");
this.stuName = stuName;
}
public Student(String stuName, String stuAge) {
this(stuName);
this.stuAge = stuAge;
System.out.println("构造方法二");
this.study();
}
public void study() {
System.out.println("我是学生,只会学习");
}
public static void main(String[] args) {
/*
运行结果:
构造方法一
构造方法二
我是学生,只会学习
*/
Student student = new Student("小明", "23");
}
}
17.super关键字
(1)在子类的成员方法中,访问父类的成员变量
(2)在子类的成员方法中,访问父类的成员方法
(3)在子类的构造方法中,访问父类的构造方法
public class Person {
String name = "我是人类";
public Person(String name) {
this.name = name;
System.out.println("父类的有参构造方法");
}
public void walk() {
System.out.println("能走路");
}
}
public class Student extends Person {
String name = "我是学生";
public Student(String name) {
super(name);
}
public void study() {
System.out.println(super.name);
super.walk();
}
public static void main(String[] args) {
/*
运行结果:
父类的有参构造方法
测试一下
能走路
*/
Student student = new Student("测试一下");
student.study();
}
}
18.static关键字
(1)static修饰的方法,叫静态方法。通过 类名.方法名 调用
(2)static修饰的变量,叫静态变量。static是不允许用来修饰局部变量,静态变量属于类,通过 类名.变量名 调用
(3)static修饰的类,叫静态内部类。static是不允许用来修饰普通外部类
(4)static修饰的代码块,叫静态代码块。jvm初始化类的时候执行
19.final关键字
(1)final修饰的类,不能被继承
(2)final修饰的方法,不能被重写
(3)final修饰成员变量,必须在定义时、代码块或者构造器中进行初始化赋值
20.instanceof运算符
判断一个对象是否属于一个类
Object var = "字符串";
//判断"字符串"是否是String类的对象
if (var instanceof String) {
String obj = (String) var;
System.out.println("Object是所有类的父类");
}
21.包装类
(1)byte Byte
(2)short Short
(3)int Integer
(4)long Long
(5)float Float
(6)double Double
(7)boolean Boolean
(8)char Character
22.构造器
(1)如果没有定义构造器,则会默认一个无参构造器
(2)如果自定义了构造器,则会覆盖默认构造器(一般都会声明空参构造器)
(3)构造器之间属于重载
public class Person {
private String personName;
private String personAge;
public Person() {
}
public Person(String personName) {
this.personName = personName;
}
public Person(String personName, String personAge) {
this.personName = personName;
this.personAge = personAge;
}
public String getPersonName() {
return personName;
}
public void setPersonName(String personName) {
this.personName = personName;
}
public String getPersonAge() {
return personAge;
}
public void setPersonAge(String personAge) {
this.personAge = personAge;
}
}
23.抽象类和接口
(1)抽象类不能实例化,但可以有构造器、属性、普通方法、抽象方法
(2)有抽象方法的类一定是抽象类
(3)子类只有重写了父类中的抽象方法后,方可实例化
(4)接口与接口之间可以继承,而且可以多继承
(5)类可以实现多个接口
(6)接口中不能定义构造器,不能实例化
(7)JDK7及以前只能定义全局常量和抽象方法,JDK8除定义全局常量和抽象方法外,增加静态方法、默认方法
public class Professor extends Man {
public Professor(String name) {
super(name);
}
@Override
public void speak() {
System.out.println("会讲话");
}
@Override
public void eat() {
System.out.println("会吃饭");
}
@Override
public void teach() {
System.out.println("会教书");
}
@Override
public void gender() {
System.out.println("是男人");
}
public static void main(String[] args) {
/*
运行结果:
是男人
会讲话
会吃饭
会花钱
会教书
老师
静态方法
默认方法
*/
Professor professor = new Professor("李斯");
professor.gender();
professor.speak();
professor.eat();
professor.spendMoney();
professor.teach();
System.out.println(Teacher.PROFESSION);
Teacher.staticMethod();
professor.defaultMethod();
}
}
/*
抽象类
*/
abstract class Man implements Person {
protected String name;
public Man(String name) {
this.name = name;
}
public abstract void gender();
protected void spendMoney() {
System.out.println("会花钱");
}
}
interface Teacher {
/*
* 静态常量
*/
String PROFESSION = "老师";
void teach();
/*
默认方法
*/
default void defaultMethod() {
System.out.println("默认方法");
}
/*
静态方法
*/
static void staticMethod() {
System.out.println("静态方法");
}
}
interface Person extends Animal, Teacher {
void speak();
}
interface Animal {
void eat();
}
24.匿名对象和匿名类
public class Student implements Person {
private Person person;
public Student(Person person) {
this.person = person;
}
@Override
public void walk() {
person.walk();
}
public static void main(String[] args) {
/*
运行结果:
我是匿名类
我是匿名对象
*/
Student student = new Student(new Person() {
@Override
public void walk() {
System.out.println("我是匿名类");
}
});
student.walk();
Student student1 = new Student(new Man());
student1.walk();
}
}
interface Person {
void walk();
}
class Man implements Person {
@Override
public void walk() {
System.out.println("我是匿名对象");
}
}
25.值传递机制
形参:方法定义时,声明的小括号内的参数
实参:方法调用时,实际传递给形参的数据
(1)如果参数是基本数据类型,此时实参赋给形参的是实参真实存储的数据值
(2)如果参数是引用数据类型,此时实参赋给形参的是实参存储数据的地址值
26.可变个数形参
(1)可变个数形参的格式:数据类型 ... 变量名
(2)当调用可变个数形参的方法时,传入的参数个数可以是n个
(3)可变个数形参的方法与本类中方法名相同,形参类型也相同的数组之间不构成重载
(4)可变个数形参在方法的形参中,必须声明在末尾
(5)可变个数形参在方法的形参中,最多只能声明一个可变形参
public class VariableArgs {
public static void main(String[] args) {
/*
运行结果:
AA
BB
CC
*/
String[] strArr = {"AA", "BB", "CC"};
showArgs(strArr);
}
public static void showArgs(String... args) {
for (int i = 0; i < args.length; i++) {
System.out.println(args[i]);
}
}
}
27.Object类
(1)Object类是所有Java类的根父类
(2)如果在类的声明中未使用extends关键字指明其父类,则默认父类为java.lang.Object类
(3)常用方法toString()、equals(Object obj)、getClass()
28.代码块
public class CodeBlock {
/*
(1)静态代码块
随着类的加载而执行,而且只执行一次
如果一个类中定义了多个静态代码块,则按照声明的先后顺序执行
静态代码块的执行要优先于非静态代码块的执行
静态代码块内只能调用静态的属性、静态的方法,不能调用非静态的结构
(2)非静态代码块
随着对象的创建而执行
每创建一个对象,就执行一次非静态代码块
如果一个类中定义了多个非静态代码块,则按照声明的先后顺序执行
非静态代码块内可以调用静态的属性、静态的方法,或非静态的属性、非静态的方法
*/
private String name;
private static String desc = "静态变量";
public CodeBlock() {
System.out.println("空参构造方法");
}
public CodeBlock(String name) {
this.name = name;
System.out.println("有参构造方法");
}
{
System.out.println("普通代码快");
System.out.println(desc);
}
static {
System.out.println("静态代码块");
System.out.println(desc);
info();
}
public static void info() {
System.out.println("静态方法");
}
public static void main(String[] args) {
/*
运行结果:
静态代码块
静态变量
静态方法
普通代码快
静态变量
有参构造方法
================
普通代码快
静态变量
有参构造方法
*/
CodeBlock codeBlock1 = new CodeBlock("测试代码块1");
System.out.println("================");
CodeBlock codeBlock2 = new CodeBlock("测试代码块2");
}
}
29.四种权限修饰符
public protected (default) private
同一个类 yes yes yes yes
同一个包 yes yes yes no
不同包子类 yes yes no no
不同包非子类 yes no no no
30.Arrays工具类
public static void main(String[] args) {
int[] arr1 = {5, 2, 6, 1, 9, 3};
/**
* void sort(int[] a) 按照数字顺序排列指定的数组
* String toString(short[] a) 返回指定数组的内容的字符串表示形式
*/
Arrays.sort(arr1);
System.out.println(Arrays.toString(arr1));
/**
* boolean equals(int[] a,int[] b):判断两个数组是否相等
*/
int[] arr2 = {5, 2, 6, 1, 9, 3};
int[] arr3 = {5, 2, 6, 1, 9, 3};
boolean isEquals = Arrays.equals(arr2, arr3);
System.out.println(isEquals);
/**
* <T> List<T> asList(T... a)返回由指定数组支持的固定大小的列表
*/
List<int[]> list = Arrays.asList(arr3);
for (int[] arr : list) {
for (int a : arr) {
System.out.println(a);
}
}
/**
* int binarySearch(int[] a,int key) 二分法查找(使用前数组需要排序)
*/
int[] arr4 = new int[]{-98, -34, 2, 34, 54, 66, 79, 105, 210, 333};
int index = Arrays.binarySearch(arr4, 210);
if (index >= 0) {
System.out.println(index);
} else {
System.out.println("未找到");
}
}
31.子类实例化过程
public class CreateSubclass {
public static void main(String[] args) {
/*
由父及子,静态先行
运行结果:
Mid的静态初始化块
Leaf的静态初始化块
Mid的普通初始化块
Mid的无参数的构造器
Mid的带参数构造器,其参数值:尚硅谷
Leaf的普通初始化块
Leaf的构造器
Mid的普通初始化块
Mid的无参数的构造器
Mid的带参数构造器,其参数值:尚硅谷
Leaf的普通初始化块
Leaf的构造器
*/
new Leaf();
System.out.println();
new Leaf();
}
}
class Mid {
static {
System.out.println("Mid的静态初始化块");
}
{
System.out.println("Mid的普通初始化块");
}
public Mid() {
super();
System.out.println("Mid的无参数的构造器");
}
public Mid(String msg) {
//通过this调用同一类中重载的构造器
this();
System.out.println("Mid的带参数构造器,其参数值:"
+ msg);
}
}
class Leaf extends Mid {
static {
System.out.println("Leaf的静态初始化块");
}
{
System.out.println("Leaf的普通初始化块");
}
public Leaf() {
//通过super调用父类中有一个字符串参数的构造器
super("调用父类");
System.out.println("Leaf的构造器");
}
}
32.内部类
(1)成员内部类 1.可以有权限修饰符 ;2.不能定义static静态资源 ;3.可以直接访问外部类静态和非静态资源 ;4.可以继承类和实现接口 ;5.实例化依赖外部类的实例 ;6.资源不能被外部类直接访问
(2)静态内部类 1.可以有权限修饰符; 2.可以定义static静态资源和非静态资源 ;3.可以直接访问外部类静态资源,但不能访问非静态资源 ;4.可以继承类和实现接口 ;5.实例化不需要依赖外部类的实 例; 6.资源不能被外部类直接访问
(3)局部内部类 1.不可以有权限修饰符,且不能声明为static ;2.声明在方法体内,只在方法体内有效; 3.可以在方法体内实例化 ;4.不能定义static静态资源 ;5.可以继承类和实现接口; 6.在静态方法内声明,只能访问外部类静态资源 ;7.在普通方法内声明,可以问外部类静态资源和非静态资源;8.访问方法内的局部变量必须是final常量
下一篇: MyBatis知识总结和梳理(2)