1.变量：类变量、实例变量、局部变量

public class Variable{
	static int allClicks=0; //类变量
	String str="hello world"; //实例变量

	public void method(){
		int i=0; //局部变量
	}
}

常量

final 常量名=值;
final double PI=3.14;

2.位运算

左移：<< 相当于*2

右移：>>相当于/2

3.输入

包：java.util.Scanner

基本语法：Scanner s=new Scanner(System.in)

通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前一般需要使用hasNext()与hasNextLine()判断是否还有输入数据。

关闭：s.close()

区别：next():输入有效字符后，后面的空格为结束符或分隔符

       nextLine():以Enter为结束符，可以获得空白

public class Demo03{
	public static void main(String[] args){
		Scanner scanner=new Scanner(System.in);
		System.out.println("请输入数据：");
		String str=scanner.nextLine();
		System.out.println("输出内容为:"+str);
		scanner.close();
	}
}

4.值传递和引用传递：java是值传递

• 值传递：创建副本，函数无法改变原始对象
• 引用传递：不创建副本，函数可以改变原始对象

java都是“值传递”，关键看这个值是什么，简单变量就是复制了具体值，引用变量就是复制了地址呗。字符串是不可变的，不会被修改。

5.方法的重载

重载就是再一个类中，有相同的函数名称，但形参不同的函数。

方法的重载的规则：

• 方法名称必须相同。
• 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。
• 方法的返回类型可以相同也可以不同。
• 仅仅返回类型不同不足以成为方法的重载。

6.可变参数

在方法声明中，再指定参数类型后加一个省略号(...)。

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通参数必须在它之前声明。

public static void printMax(double... numbers){
	if (numbers.length == 0){
		System.out.println("No argument passed");
		return;
	}
	double result=numbers[0];

	//排序
	for (int i=1;i<numbers.length;i++){
		if (numbers[i]>result){
			result=numbers[i];
		}
	}
	System.out.println("The max value is" + result);
}

7.递归

递归结构包含两个部分：

• 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
• 递归体：什么时候需要调用自身方法。

8.数组

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

dataType[] arrayRefVar; //首选的方法
或
dataType arrayRefVar[]; //效果相同，但不是首选方法

java语言使用new操作符来创建数组，语法如下：

dataType[] arrayRefVar = new dataType[arraySize]; 

数组元素通过索引访问，数组索引从0开始。

获取数组长度：

array.length;

例：

public static void main(String[] args){
	int[] nums; //1.声明一个数组
	nums = new int[10]; //2.创建一个数组

//or
	int[] nums = new int[10]; //声明并创建一个数组
}

java内存：

• 堆：存放new的对象和数组，可以被所有的线程共享，不会存放别的对象引用。
• 栈：存放基本变量类型（会包含这个基本类型的具体数值），引用对象的变量（会存放这个引用在堆里面的具体地址）

三种初始化：

• 静态初始化：创建+赋值

int[] a = {1,2,3};

• 动态初始化：包含默认初始化

int[] a=new int[2]; //默认初始化为0
a[0]=1;
a[1]=2;

数组的四个基本特点：

• 其长度是确定的，数组一旦被创建，它的大小就不可以改变。
• 其元素必须是相同类型，不允许出现混合类型。
• 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
• 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

冒泡排序：

public static void sort(int[] array){
	//临时变量
	int temp = 0;
	//外层循环，判断要走多少次；
	for (int i = 0; i < array.length-1; i++){
		//内层循环，比较两个数，如果第一个数比第二个数大，则交换位置
		for (int j = 0; j < array.length-1-i; j++){
			if (array[j+1]>array[j]){
				temp = array[j];
				array[j] = array[j+1];
        array[j+1] = temp;
			}
		}
	}
}

稀疏数组：

9.面向对象（Object-Oriented Programming, OOP）

本质：以类的方式组织代码，以对象的形式封装数据

三大特性：封装、继承、多态

10.方法调用

• 静态方法：

//类名.方法名()
Student.say();

• 非静态方法：

//对象类型 对象名=对象值;
Student student=new Student();
student.say();

静态方法不能调用非静态方法：因为静态方法和类一起加载，而非静态方法是在类实例化以后才存在。

11.类与对象

• 类：是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一具体事物。
• 对象：是抽象概念的具体实例。

使用new关键字创建对象

//类：抽象的，实例化
//类实例化后会返回一个自己的对象！
//student对象就是一个Student类的具体实例
Student student = new Student();

构造器：

• 和类名相同
• 没有返回值

作用：

• new本质在调用构造函数
• 初始化对象的值

注意点

• 定义有参构造之后，如果想使用无参构造，必须显式定义一个无参的构造

public class Person{
	//一个类即使什么都不写，它也会存在一个方法
	//显式的定义构造器

	String name;
	
	//实例化初始值
	//1.使用new关键字，本质是在调用构造器
	public Person(){} //构造器和类名相同
	
	//有参构造：一旦定义了有参构造，无参构造就必须显式定义
	public Person(String name){
		this.name = name;	
	}
}

12.创建对象内存分析

堆中存放new的数组和对象

栈中存放基本数据类型

13.封装

高内聚：类的内部数据操作细节自己完成，不允许外部干涉

低耦合：仅暴露少量的方法给外部使用

属性私有，get/set

public class Student{
	//属性私有
	private String name;
	private int id;
	private char sex;

	//提供一些可以操作这个属性的方法！
	//提供一些public的 get、set方法

	//get 获得这个数据
	public String getName(){
		return this.name;
	}
	
	//set 给这个参数设置值
	public void setName(String name){
		this.name = name;
	}
}

14.继承

关键字：extends

Java中只有单继承，没有多继承。“一个儿子只能有一个爸爸，一个爸爸可以有多个儿子”

//Person 人：父类
public class Person{
	//public 子类可以继承
  //private 子类无法继承
	public int money=100000;
	public void say(){
		System.out.println("说了一句话");
	}
}
----------------------------------------------------
//学生 is 人：派生类，子类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{}

//老师 is 人
public class Teacher extends Person{}

继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。

在Java中，所有的类，都默认直接或间接继承Object类。

super 和 this：

//Person 人：父类
public class Person{
	public Person(){
		System.out.println("Person");
	}
	
	protected String name = "aaa";
	
	public void print(){
		System.out.println("Person");
	}
}
--------------------------------------------------------------
//学生 is 人：派生类，子类
//子类继承了父类，就会拥有父类全部方法
public class Student extends Person{
	public Person(){
		//创建子类对象时，会先执行父类构造函数，再执行子类构造函数
		//隐藏代码: super(); //调用父类的构造器必须要在子类构造器的第一行
		System.out.println("Student");
	}
	
	private String name = "bbb";

	public void print(){
		System.out.println("Student");
	}

	public void test1(){
		print(); //调用当前类Student的print()函数
		this.print(); //调用当前类Student的print()函数
		super.print(); //调用父类Person的print()函数
	}
	
	public void test(String name){
		System.out.println(name); //输出传入的参数
		System.out.println(this.name); //输出当前类Student的name值bbb
		System.out.println(super.name); //输出父类Person的name值aaa
	}
}

super注意点：

• super调用父类的构造方法，必须在构造方法的第一个。
• super必须只能出现在子类的方法或构造方法中。
• super和this不能同时调用构造方法。

super vs this：

• 代表对象不同：this代表本身调用者这个对象；super代表父类对象的引用。
• 前提：this在没有继承也能使用；super只能在继承条件下使用。
• 构造方法：this()调用本类构造方法；super()调用父类构造。

方法的重写：

//重写都是方法的重写，与属性无关
public class B{
	public static void test(){
		System.out.println("B=>test()");
	}
}

--------------------------------------
public class A extends B{
	public static void test(){
		System.out.println("A=>test()");
	}

	}

-------------------------------------------
public class Demo{
	//静态方法和非静态方法区别很大
	public static void main(String[] args){
		//方法的调用只和左边定义的数据类型有关
		A a=new A();
		a.test(); //输出A=>test()
		
		//父类的引用指向了子类
		B b=new A();
		b.test(); //输出B=>test()
	}
}

静态方法和非静态方法区别很大：

• 静态方法：方法的调用只和左边定义的数据类型有关
• 非静态方法：

静态方法是类的方法（类的成员），而非静态方法是对象的方法。有static时，b调用了B类的方法，因此b使用B类定义的；没有static时，b调用的是对象的方法，而b使用A类new的，即b是A new出来的对象，因此调用了A的方法。

重写注意点：需要有继承关系，子类重写父类方法

• 方法名必须相同
• 参数列表必须相同
• 修饰符：范围可以扩大 但不能缩小public>Protected>Default>private
• 抛出的异常：范围可以缩小，但不能扩大

15.多态

public class Person{
	public void run(){
		System.out.println("run");
	}
}

------------------------------------
public class Student extends Person{
	public void run(){
		System.out.println("son");
	}

	public void eat(){
		System.out.println("eat");
	}
}

-----------------------------------------
public class Demo{
	public static void main(String[] args){
		//一个对象的实际类型是确定的
		//new Student();
		//new Person();

		//可以指向的引用类型就不确定了:父类的引用指向了子类		
		
		//Student能调用的方法都是自己的或者继承父类的！
		Student s1 = new Student();
		//Person 父类型，可以指向子类，但是不能调用子类独有的方法
		Person s2 = new Student();
		Object s3 = new Student();
	
		//对象能执行哪些方法，主要看对象左边类型，和右边关系不大！
		s2.run(); //子类重写了父类的方法，执行子类的方法
		s1.run();
	}
}

多态注意事项：

• 多态是方法的多态，属性没有多态。
• 有父类子类关系才能转换
• 存在条件：1.有继承关系；2.方法需要重写；3.父类引用指向子类对象：father f1=new son();

哪些方法不能被重写：

• 1.static方法：属于类，不属于实例
• 2.final：常量，无法修改
• 3.private方法

**instanceof 关键字：**判断一个对象是什么类型

public class Person{
	
}

------------------------------------
public class Student extends Person{
	
}

------------------------------------
public class Teacher extends Person{
	
}

-------------------------------------
public class Demo{
	public static void main(String[] args){
		
		//Object > String
		//Object > Person > Student
		//Object > Person > Teacher
		Object object = new Student();

		//System.out.println("x instanceof Y"); //能不能编译通过看它们有没有父子关系
		
		System.out.println(object instanceof Student); //true
		System.out.println(object instanceof Person); //true
		System.out.println(object instanceof Object); //true
		System.out.println(object instanceof Teacher); //false
		System.out.println(object instanceof String); //false
		System.out.println("========================");
		Person person = new Student();
		System.out.println(person instanceof Student); //true
		System.out.println(person instanceof Person); //true
		System.out.println(person instanceof Object); //true
		System.out.println(person instanceof Teacher); //false
		System.out.println(person instanceof String); //编译报错
		System.out.println("========================");
		Student student = new Student();
		System.out.println(student instanceof Student); //true
		System.out.println(student instanceof Person); //true
		System.out.println(student instanceof Object); //true
		System.out.println(student instanceof Teacher); //编译报错
		System.out.println(student instanceof String); //编译报错
	}
}

类型转换：

public class Person{
	public void go(){
		System.out.println("run");
	}
}

------------------------------------
public class Student extends Person{
	public void go(){
		System.out.println("go");
	}
}

------------------------------------
public class Teacher extends Person{
	public void go(){
		
	}
}

-------------------------------------
public class Demo{
	public static void main(String[] args){
		//类型之间转换
	}
}