概述

这个就是记录一些重要一点的语法–具体语法取自菜鸟教程

因此，就是大致了解，后面准备直接开Spring

下面是杂七杂八的一些东西：

入口

1
2
3

public static void main(String[] args){
	System.out.println("hello world")
}

大小写

大小写敏感，采用驼峰或者蛇形（推荐驼峰，个人习惯）
类大写
方法小写
源文件名必须与方法名相同
入口可以有很多
常量大写

标识符

字母 + $ + _ 三种类型开头，其他不行
合法标识符举例：age、$salary、_value、__1_value
非法标识符举例：123abc、-salary

修饰符

访问控制：

public
default
protected
private

变量修饰符

final
abstract
static
synchronized

变量

局部变量
类变量（静态变量）
成员变量（非静态变量）
枚举就是一个特殊的类

关键字

忒多了

注释

// 单行注释

/*多行注释 */ 

/**
*	文档
*	注释
		*/

包

没啥用，就是用来给类归归类啥的，顺便定义一下访问权限

简述一下高级概念

类：对象的模板，有着对象的共性 ——狗，猫，类就是animal

对象：类的实例，状态加行为 ——狗，猫，你

只有类的话是不能使用的，必须要初始化成实例（除非使用类变量）

与C相似用法

数据类型

内置数据类型
引用数据类型

内置

byte
int
double
boolean
char
String

引用类型

对象
数组
引用类型默认值为 null

常量

1	final double PI = 3.14

转义字符

差不多

自动类型转换

1
2
3

低  ------------------------------------>  高

byte,short,char—> int —> long—> float —> double

强制类型转换

1	byte b = (byte)a

变量

局部变量
实例变量

1
2
3

public class ExampleClass {
    int instanceVar; // 实例变量
}

静态变量/类变量

类变量是在类中用 static 关键字声明的变量，它们属于类而不是实例，所有该类的实例共享同一个类变量的值，类变量在类加载时被初始化，而且只初始化一次。
参数变量
- 值传递
- 引用传递

生命周期

静态变量的生命周期与程序的生命周期一样长，即它们在类加载时被创建，在整个程序运行期间都存在，直到程序结束才会被销毁。因此，静态变量可以用来存储整个程序都需要使用的数据，如配置信息、全局变量等。

常量和静态变量的区别

常量也是与类相关的，但它是用 final 关键字修饰的变量，一旦被赋值就不能再修改。与静态变量不同的是，常量在编译时就已经确定了它的值，而静态变量的值可以在运行时改变。另外，常量通常用于存储一些固定的值，如数学常数、配置信息等，而静态变量通常用于存储可变的数据，如计数器、全局状态等。

循环+条件+运算符

哈哈哈

构造方法

我觉得难的

访问控制修饰符

具体的作用就是

访问权限的控制符能够控制类中成员的可见性。

比如A要访问B的数据，然后在B的每个数据前放一个访问控制修饰符，表示哪些数据A能拿到，哪些数据拿不到

public
公共的

就是在任何类 ，任何包 ，都能够访问
private
私有的

只能在 所在类 能够访问
protected
对同一包中的类可见、对同一包及不同包中的子类可见
default
默认，可以省略

就是在 同一包的任何类中可以访问

修饰符	当前类	同一包内	子孙类(同一包)	子孙类(不同包)	其他包
`public`	Y	Y	Y	Y	Y
`protected`	Y	Y	Y	Y/N（说明）	N
`default`	Y	Y	Y	N	N
`private`	Y	N	N	N	N

其他修饰符

static
1. 修饰字段
  
  一般用于静态常量
  1
  public static final double PI = 3.14
2. 修饰方法
  
  被static修饰的方法，称为静态方法。静态方法是不用实例化对象就可以执行的方法。调用普通的方法时，首先需要实例化对象，然后再调用方法；调用静态方法时，不需要实例化对象，可以直接调用方法。
  
  跟类变量差不多噢
3. 修饰代码块
  
  如果类的静态字段需要比较复杂的初始化代码时，可以使用静态代码块。将代码放在一个块中，并将该块标记为static，那么就构造了静态代码块。（暂时不了解）
4. 静态导入包（暂时不了解）
5. 静态内部类（暂时不了解）
final
final 一旦赋值后，不能被重新赋值，表示”最后的，最终的”

final + 方法 = 防止方法的内容被修改

final + 类 = 没有类能够继承final的任何特性
abstract(以后再说)
synchronized(以后再说)
transient（。。）
volatile(以后。。)

继承

多重继承/单重继承

儿子继承老子的共性，孙子继承老子的共性
不同类继承同一个类

儿子1 继承老子的共性，儿子2 继承老子的共性

public class Animal {
	private String name;
    private int id;
    public Animal(String name, int id){
    	this.name = myname;
         this.id = myid;
    }
    public void eat(){
        //...
    }
    public void sleep(){
        //....
    }
}
class Cat extends Animal{
    public Cat(String myname, int myid){
        super(myname,myid);
    }
}
class Dog extends Animal{
    public Dog(String myname, int myid){
        super(myname,myid);
    }
}

super/this

所有对象的父类都是 Object 类，这就意味着，所有的对象实例化的时候都需要先调用 Object 的无参构造方法;

而连接对象和 Object 至少需要一条道路，而 this 和 super 就是这个最重要的桥梁;

而 this 和 super 两个往往身藏功与名，默默无闻，很多情况都可以省略。

比如：

本类方法调用本类属性

本类方法调用另一个本类方法

子类构造方法隐含调用 super()

this

class Person {
    private int age = 10;
    public Person(){
    System.out.println("初始化年龄："+age);
}
    public int GetAge(int age){
        this.age = age;
        return this.age;
    }
}
 
public class test1 {
    public static void main(String[] args) {
        Person Harry = new Person();
        System.out.println("Harry's age is "+Harry.GetAge(12));
    }
}

初始化年龄：10
Harry’s age is 12

super

class Country {
    String name;
    void value() {
       name = "China";
    }
}
  
class City extends Country {
    String name;
    void value() {
    name = "Shanghai";
    super.value();      //调用父类的方法
    System.out.println(name);
    System.out.println(super.name);
    }
  
    public static void main(String[] args) {
       City c=new City();
       c.value();
       }
}

Shanghai
China

注意到，这里this，super都是引用，是给引用的一行赋值

this引用了同类的变量

super引用了父类的变量

this表示当前对象：
    this.属性 区别成员变量和局部变量
    this.() 调用本类的某个方法
    this() 表示调用本类构造方法，只能用在构造方法的第一行语句。
    this关键字只能出现在非static修饰的代码中

super表示父类对象：
    super.属性 表示父类对象中的成员变量
    super.方法()表示父类对象中定义的方法
    super() 表示调用父类构造方法
        可以指定参数，比如super("Tom",23);
        任何一个构造方法的第一行默认是super();
        可以写上，如果未写，会隐式调用super();
    super()只能在构造方法的第一行使用。
    this()和super()都只能在构造的第一行出现，所以只能选择其一。
    写了this()就不会隐式调用super()。

Override 重写

子类把父类中相同的方法核心换一下

例如：

父类动物吃东西

子类羊吃草

public class Animal{
    public void eat(){
        System.out.println("eat food");
    }
}
class Sheep extends Animal{
    public void eat(){
        System.out.println("eat cao");
    }
}

规则

参数，方法名相同，返回类型必须是派生值
重写的访问权限必须比父类的方法要高
final static private 不能重写 – static 可以重新申明
构造方法不能重写
如果调用父类的被重写方法，可以用 super

Overload重载

相同类，同一个名字，不同返回类型，参数，核心

其中参数列表必须改变，其他可以改变

多态

同一事件在不同对象上会产生不同的结果

动物都是吃东西

狼吃肉，羊吃草

多态存在的必要条件

继承
重写
父类引用指向子类对象
1
Animal animal = new Sheep()

抽象类

就是模糊定义对象，没有足够的信息描绘一个具体的对象

不能实例化对象

但是抽象类可以被继承，由此可以进行实例化

抽象方法

在所有的普通方法上面都会有一个“{}”，这个表示方法体，有方法体的方法一定可以被对象直接使用。而抽象方法，是指没有方法体的方法，同时抽象方法还必须使用关键字abstract做修饰。

package com.wz.abstractdemo;

abstract class A{//定义一个抽象类
	
	public void fun(){//普通方法
		System.out.println("存在方法体的方法");
	}
	
	public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
	
}

public class TestDemo {

	public static void main(String[] args) {
		A a = new A();
	}
}

声明抽象方法会造成以下两个结果：

如果一个类包含抽象方法，那么该类必须是抽象类。
任何子类必须重写父类的抽象方法，或者声明自身为抽象类。

注意：

1. 抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。
1. 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
1. 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。
1. 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。
1. 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

封装

public class Person{
	private String name;
	public String getName(){
		return name;
	}
}

把数据包装起来

接口

抽象方法的集合

枚举

1
2
3

enum Color {
	RED,GREEN,BLUE
}