1、java语法

1、内存单位

符号	标识符	名称	别名	说明	示例
bit	b (小写)	位	比特位	信息最小单元，不是存储单元	0111 1101 (8个位)
byte	B (大写)	字节	–	最小存储单元	0111 1101 (1个字节)

打个比方：仓库要存放牛奶，但是必须一件一件地存放，而不能一袋一袋地存放。
字节也是一样，仓库要存放字节，但是必须一个一个字节地存放，而不能一个一个位地存放。

换算：

1B （字节）	= 8 bit (位)
1KB	= 1024B
1MB	= 1024KB
1GB	= 1024MB
1TB	= 1024GB

---

感受一下存储单元：（想象一下在C盘、D盘…中密密麻麻全是字节）
Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte
01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101 01111101

**另外： **一般一个汉字占两个字节
[
你(01111101 01111101) 好(01111101 01111101) 世(01111101 01111101) 界(01111101 01111101)
你(01111101 01111101) 好(01111101 01111101) 世(01111101 01111101) 界(01111101 01111101)
你(01111101 01111101) 好(01111101 01111101) 世(01111101 01111101) 界(01111101 01111101)
你(01111101 01111101) 好(01111101 01111101) 世(01111101 01111101) 界(01111101 01111101)
你(01111101 01111101) 好(01111101 01111101) 世(01111101 01111101) 界(01111101 01111101)
] ( 20Byte ) * 50 = 1000KB < 1024KB
1KB可以 放得下503个汉字。

一个英文字母占用一个字节
[
H （01111101） E（01111101） L（01111101） L（01111101） O（01111101）
W（01111101） O（01111101） R（01111101） L（01111101） D（01111101）
] （10Byte） * 100 = 1KB
刚好 1KB可以 放得下 102个字母
[HELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLDHELLOWORLD
] 这里就是1KB
我们敲的代码一个HTML算上空格，能放几个KB就行；、，

2、数组

数组的声明	说明
int[] arr;	声明一个int数组变量，变量名为arr
int arr[];	声明一个变量，变量名为arr数组
int[] arr = {1,2,3}
int[] arr = new int[3]	声明长度为3的空数组，int数组默认值为0
int[] arr = new int[]{1,2,3}	如果不给长度，那么必须给初始值

3、字符串

类	特点	说明
String	一旦声明一个字符串，便不能更改	大量使用会：慢，浪费资源
StringBuilder	值可以改变	可以通过toString方法转为String

4、集合

单词	名称	优点	说明
ArrayList	集合数组	长度是可变的，比数组[]好，还提供了很多常用的方法，比如排序啊，，等；集合数组还可以存放任何类型的数据	arr.add(“你好”)

5、权限修饰符

修饰方法、成员变量、类
权限和状态可以同时对一个地方使用。

分类	修饰符	同一个类中	同一个包中 子类无关类	不同包的子类	不同包的无关类
权限修饰符	private	能访问
	默认	能访问	能访问
	protected	能访问	能访问	能访问
	public	能访问	能访问	能访问	能访问
状态修饰符	修饰符	修饰方法	修饰变量		修饰类
	final	不能被重写	表明为常量，变量不能再次赋值		不能被继承
	static	类方法,类方法只能访问类变量	类变量，被类的所有对象共享

注意：final修饰引用类型的变量时，变量的地址不能变，但是值是可以改变的。

public final class Student{

	public String name;
    
    public static String age;
    
    int year;
    
    protected String hiib;
    
    private String ree;
    
    
}

6、java三大特性

	优点	缺点
继承	提供复用性	单继承，对父类的扩展性不太好
封装	提供安全性，复用性
多态	对象的多种形态，对父类的引用可以指向子类的对象；还表现为重写，重载方法；

//多态状态下。编译看左边，执行看右边。
//比如：
Animal animal = new Cat();
animal.showName();
//编译能不能通过，要看左边Animal类是否有showName方法。
//能不能执行，要看右边，子类Cat有没有showName方法。

7、抽象类

在java中，一个没有方法体的方法应该定义为抽象方法。
而类中如果包含有抽象方法，该类必须定义为抽象类

public abstract class Animal{
   public abstract void eat();
}

1、抽象类不能用来创建对象
~~new Animal() ~~
2、抽象类中可以包含具体方法。

public abstract class Animal{
   public abstract void eat();
    
    public void sleep(){
    	System.out.println("睡觉")
    }
}

3、使用多态方式来创建对象

public abstract class Animal{
   public abstract void eat();
    
    public void sleep(){
    	System.out.println("睡觉");
    }
}
public class Cat extends Animal{
	public void eat(){   //子类必须重写eat方法
    	System.out.println("吃饭");
    }
}

Animal anc = new Cat();
anc.eat()

4、抽象类的子类要么重写抽象方法，要么子类也是抽象类

8、接口

java中的接口更多的体现在对行为的抽象

1、使用 interface 关键字

public interface Jumpping{
	public abstract jump();
}

2、子类使用 implements 来实现接口

public Cat implements Jumpping{
	
    @override
    public void jump(){
    	System.out.prinln("跳远")
    }
}

3、多个子类 可以同时实现一个接口

public Dog implements Jumpping{
	
}

9、抽象类和接口的区别

抽象类是对事物的抽象，而接口是对行为的抽象。

对于上面的需求，单独使用抽象类和接口都不合适。可以使用抽象类和接口相搭配。
单独使用抽象类，那么所有的门都需要重写 警报方法，显然不合适。
单独使用接口，那么开门和关门又不能提取出来，不符合代码的复用性。
两者搭配就好了。

10、内部类

在一个类中定义一个类。
比如：
笔记本类–》CPU类

1、成员内部类

public class 类名{

	修饰符 class 类名{
    
    }
}
//范例：
public class Outer{
	
    public class Inner{
    
    }
}

1、内部类可以直接访问外部类的成员，包括私有

public class Outer{
	private String name = "张三"
    public class Inner{
    	public void showname(){
        	System.out.println(name)
        }
    }
}

2、外部类要访问内部类的成员，必须创建对象

public class Outer{
    public class Inner{
        private String name = "张三"
    }
    
    public void showname(){
        Inner inner = new Inner();
        System.out.println(inner.name);
    }
}

3、在外部(其他类)如何创建内部类

public class Outer{
    public class Inner{
        private String name = "张三"
    }
    
    public void showname(){
        Inner inner = new Inner();
        System.out.println(inner.name);
    }
}

public class Test{

	public static void main(String[] args){
    	//Inner inner = new Inner();  //错误
        Outer.inner oi = new Outer().new Inner();
    }
}
//格式
外部类名.内部类名 = 外部类对象.内部类对象

但是，一般来说不会用这种方式来创建内部类。
而是创建外部类，在外部的方法中去执行内部类要执行的东西。这样更符合

2、局部内部类

在外部类的某个方法中，出现了类

public class Outer{

	private int num = 0;
    
    public void method{
    
    	class Inner{
        	public void show(){
            	System.out.prinln(num);
            }
        }
    }

}

这种情况，外部是不能创建内部类的对象的。

3、匿名内部类

匿名内部类是局部内部类的一种。
前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类。
格式：

new 类名或者接口名(){
	重写方法;
}

范例：

new Inner(){
	public void show(){
    
    }
}

本质:是一个继承了该类或者实现了该接口的子类匿名对象

public interface Inter{
    void show();
}

public class Outer{
	public void method{
    	/*
        new Inter(){
        	@Override
            public void show(){
            	System.out.println("匿名内部类")
            }
        }
        */
    	
        /*
        new Inter(){
        	@Override
            public void show(){
            	System.out.println("匿名内部类")
            }
        }.show();   //为了让外部可以调用得到
        */
        
        /*
        Inter i = new Inter(){   //使用多态的形式
        	@Override
            public void show(){
            	System.out.println("匿名内部类")
            }
        }
        
        i.show(); 
        i.show(); //实现多次调用
        */
    }
}

使用匿名内部类，可以少创建一个类哦。
说白了就是：我想要一个类，来执行某个接口的方法，但是，我并不想为了这个就去创建一个类。就可以使用一个没有名字的类。

11、基本类型和包装类

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据常用的操作之一；用于基本数据类型与字符串之间的转换。

基本数据类型	包装类
byte (字节) 如：92 ------>a	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

12、集合体系

特点：提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变。

1、Collection接口没有直接的实现类
2、List有序、可重复

List<String> list = new ArrayList<>();
list.add("hello");
list.add("world");

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()){
    System.out.println(iterator.next());

}

List<String> list = new ArrayList<>();
list.add("hello");
list.add("world");
System.out.println(list);

list.set(1,"你好");   //修改 List的某个值，注意：不能索引越界，要报错
System.out.println(list);

list.size();// 获取list的长度
list.get(1); //获取索引为1的值

13、数据结构

1、栈和队列

2、数组和链表

数组

链表

添加一条

删除一条

3、哈希表

JDK8之前，底层采用数组+链表实现，可以说是一个元素为链表的数组。
JDK8以后，在长度比较长的时候，底层实现了优化。

相同则不存

内容不同也要存

14、哈希值

JDK根据对象的地址或者字符串或者数字算出来的int类型的数值。

Object有个 hashCode()方法可以返回对象的Hash值。
哈希值的特点：
1、默认下一个对象只有一个哈希值，多次调用也相同，但是不同对象的哈希值不相同。

Student s1 = new Student();
System.out.println(s1.hashCode());  //1060830840
System.out.println(s1.hashCode());  //1060830840

通过重写hashCode方法就可以改变默认情况，进而控制哈希值。

15、泛型

把类型参数化，泛型只能指向引用类型。

1、泛型类

修饰符 class 类名<类型>{}
范例：  public class Generic<T>{}
此处的T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。

public class Student<T>{
    
    private T t;  //拿到类上面定义的类型。

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

Student<String> s1 = new Student<String>();
s1.setT("hello");

Student<Integer> s2 = new Student<Integer>();
s2.setT(30);

2、泛型方法

修饰符<类型> 返回值类型方法名(类型 变量名){}
public void show(T t){}

/**
* 普通
**/
public class Student{
    public void show(String s){
        System.out.println(s);
    }
    public void show(Integer s){
        System.out.println(s);
    }
    public void show(Boolean s){
        System.out.println(s);
    }
}
/**
* 泛型类改进
**/
public class Student<T>{
    public void show(T s){  //普通方法，只是用到了类的泛型
        System.out.println(s);
    }
}
/**
* 泛型方法改进
**/
public class Student{
    public <T> void show(T s){     //这才是独立的泛型方法。
        System.out.println(s);
    }
}

泛型方法可以接受任意类型的参数。

3、泛型接口

修饰符 interface 接口名<类型>{}
public interface gerrrt{}

public interface gerrrt<T>{
    void showname(T t);
}

4、类型通配符

public class Student<T>{
    public static void main(String[] args) {
        List<?> list1 = new ArrayList<Object>();  //任意类型都符合
        List<? extends Number> list2 = new ArrayList<Object>(); //报错：必须是Number的子类
    	List<? super Number> list2 = new ArrayList<Object>(); //正确
    }
}

#### 5、可变参数 **修饰符 返回值类型 方法名(数据类型... 变量名){}**
**publicc static int sum(int...a){}** ```java public class Student{ public int sum(int... a){ //a此时表示一个数组 int sum = 0; for(int i:a){ sum += i; } return sum; } } ``` **如果还有参数，可变参数放最后面** ```java public class Student{ public int sum(String b,int... a){ //a此时表示一个数组 int sum = 0; for(int i:a){ sum += i; } return sum; } } ```

16、Map集合

interface Map<K,V>
不能包含同一个键，每个键可以映射最多一个值。

//多态方式创建Map集合
Map<String,String> map = new HashMap<String,String>();
map.put("name","zs");
map.put("age","20");

遍历1

Set<String> keys = map.keySet(); //["name","age"]
for (String k:keys){
    System.out.println(k); // name ,age
    System.out.println(map.get(k));//zs 20
}

遍历2

Set<Map.Entry<String, String>> entries = map.entrySet();
System.out.println(entries);   //[name=zs, age=20]
for (Map.Entry<String, String> et:entries){
    System.out.println(et);  //name=zs  ,age=20
    String key = et.getKey();  //name  ,  age
    String value = et.getValue();  //zs  ,  20
}