JAVA笔记01

java超神之路，所有的资源再这里了

JAVA三大版本的介绍

• java se 标准版用于个人的计算机
• java ee 企业版，在服务端应用。
• JAVA me 微型版，定位在消费性电子产品的应用上。一定要和安卓开发区分开

java的特性以及专有名词介绍

Java特性

• 跨平台可移植性
• 安全性
• 面向对象
• 简单性
• 高性能
• 分布式
• 多线程
• 健壮性

java概念

包

起作用是把比较接近的类放在同一个包下，对于每一个类来说，我们必须在代码开始的地方首先说明该类所在的包名，组织形式如果为package1/package2 则包名为package1.package2

使用其他包下的类，我们需要import这个包名（jar包原理相同）

分类:
自身：指的是Hero自己
同包子类：ADHero这个类是Hero的子类，并且和Hero处于同一个包下
不同包子类：Support这个类是Hero的子类，但是在另一个包下
同包类： GiantDragon 这个类和Hero是同一个包，但是彼此没有继承关系
其他类：Item这个类，在不同包，也没有继承关系的类

访问修饰符

关键字static & final

final 修饰一个变量，有很多种说法，比如不能改变等等
准确的描述是 当一个变量被final修饰的时候，该变量只有一次赋值的机会
final 除了修饰变量，还可以修饰类，修饰方法，这些都在后续的章节展开
如果final修饰的是参数，能否在方法里给这个参数赋值？
不能 多次调用，肯定会多次赋值，不符合final的设计理念

当一个属性被static修饰的时候，就叫做类属性，又叫做静态属性
当一个属性被声明成类属性，那么所有的对象，都共享一个值
与对象属性对比：
不同对象的 对象属性 的值都可能不一样。
比如盖伦的hp 和 提莫的hp 是不一样的。
但是所有对象的类属性的值，都是一样的

类属性&访问类属性

类属性： 又叫做静态属性
对象属性： 又叫实例属性，非静态属性

如果一个属性声明成类属性，那么所有的对象，都共享这么一个值
static String copyright;
访问类属性的方法

text.printHello()
text t = new text;
t.printHello();

访问一个对象方法，必须建立在有一个对象的前提的基础上
访问类方法，不需要对象的存在，直接就访问

初始化

• 对象属性的初始化方式有三种
  声明的时候直接初始化
  初始块初始化
  构造器初始化

class text{
	String name = "string";
	int temp;
	{
		temp=3;
	}
	public Hero(){
		temp =3;
	}
}

• 类属性的初始化方法
  1、声明该属性的时候初始化
  2、静态初始化块

	class text{
		static int temp=3;
		static int flag;
		static{
			flag=3;
		}
	}

Java基础

基本类型

如果任何运算单元的长度都不超过int,那么运算结果就按照int来计算 
如果有任何运算单元的长度超过int,那么运算结果就按照最长的长度计算

比如
int a = 5;
long b = 6;
a+b -> 结果类型是long
如果任何运算单元的长度都不超过int,那么运算结果就按照int来计算
byte a = 1;
byte b= 2;
a+b -> int 类型

变量

字段，属性，Field

如果一个变量，是声明在一个方法上的，就叫做参数
参数的作用域即为该方法内的所有代码
其他方法不能访问该参数
类里面也不能访问该参数

操作符

算数操作符
‘+ - * / % ++ --’
关系操作符:比较两个变量之间的关系
> 大于
>= 大于或等于
< 小于
<= 小于或等于
== 是否相等
!= 是否不等

位操作符
public class HelloWorld {
public static void main(String[] args) {
int i = 5;
String b = (Integer.toBinaryString(i)); // 5的二进制的表达101
System.out.println(i+" 的二进制表达是: "+b);
}
}
三元操作符
?:
int k = i < j ? 99 : 88;

枚举

枚举类型主要用法是和switch相结合使用，枚举的基本使用方法如下所示

enum Season{
	SPRING,SUMMER,AUTUMN,WINTER
}
Season season = Season.SPRING;
switch(season){
	case SPRING:
		System.out.println("春天");
	·
	·
	·
	
}

• 使用枚举的好处
  假设在使用switch的时候，不是使用枚举，而是使用int，而int的取值范围就不只是1-4，有可能取一个超出1-4之间的值，这样判断结果就似是而非了。（因为只有4个季节）
• 遍历枚举
  借助增强型for循环，可以很方便的遍历一个枚举都有哪些常量

for(Season s:Season.values()){
	System.out.println(s);
}

Scanner 获取键盘输入

import java.util.Scanner;
需要注意的是，如果在通过nextInt()读取了整数后，再接着读取字符串，读出来的是回车换行:"\r\n",因为nextInt仅仅读取数字信息，而不会读取回车换行"\r\n".

所以，如果在业务上需要读取了整数后，接着读取字符串，那么就应该连续执行两次nextLine()，第一次是取走回车换行，第二次才是读取真正的字符串

Scanner in = new Scanner(System.in);
System.out.println("请输入名字");
String name = in.nextLine();
System.out.println(name);
System.out.println("请输入年龄");
int age = in.nextInt();
System.out.println("已经来的时间"+365*age);

数组

声明过程

int[] a; 声明了一个数组变量。
[]表示该变量是一个数组
int 表示数组里的每一个元素都是一个整数
a 是变量名
但是，仅仅是这一句声明，不会创建数组
创建数组的时候，要指明数组的长度。
new int[5]

引用概念：

如果变量代表一个数组，比如a,我们把a叫做引用
与基本类型不同
int c = 5; 这叫给c赋值为5
声明一个引用 int[] a;
a = new int[5];
让a这个引用，指向数组

初始化

int []a=new int [5]
int[] a= new int[]{1,2,3,4}

注：增强型for循环只能用来取值，却不能用来修改数组里的值

数组的常用方法和属性

• 获取数组长度
  数组的一般成员属性length 注意非方法
  a.length

• 数组复制
  arraycopy函数 属于系统方法
  把一个数组的值，复制到另一个数组中
  System.arraycopy(src, srcPos, dest, destPos, length)
  src: 源数组
  srcPos: 从源数组复制数据的起始位置
  dest: 目标数组
  destPos: 复制到目标数组的起始位置
  length: 复制的长度

• copyOfRange:
  int[]b= Arrays.copyOfRange(a,0,3);
  参数代表起始的位置，需要注意的是范围为【0，3）函数返回类型为arrays

• 排序
  sort函数
  排序方法Arrays.sort(a)最后的结果是升序排序
  最后的结果会对a数组本身产生影响

• 查找
  Arrays.binarySearch(a,ele);
  在使用binarySearch进行查找时，应首先进行过Arrays.sort(a)

• 相等
  equals()
  a.equals()
  ==
  区分python中的is中

二维数组

int[][] b = new int[2][]; //有两个一维数组，每个一维数组的长度暂未分配

面向对象

面向对象的关键是在宏观中进行把握，在宏观上进行调控。相当于是组织的作用

对象引用与指向

每次new 都会创建新的对象
A h=new A()
h称作对A对象的引用
而引用的过程称作指向过程
当一个引用指向另一个对象时，如果源对象没有其他引用指向的话，则会被jvm回收
也就是说只有当new时才会产生新的对象

继承

• 关键字extends
  当一个类 继承主类之后可以享有所有非private级别的属性和方法，一般来说，默认所有的属性值全部为private级别，而getter和setter方法为public级别，方便对输入输出值进行控制.
  class text extents main_class{
  }
  值得注意的是所有的子类，默认继承父类的构造方法，使用方法如下
  父类中有的构造器，在子类中通过super()方法进行调用，但是，super()方法一定在其他元素初始化之前进行调用
• 关键字this
  this关键字代表当前对象，可以调用当前类中所有的成员变量
  打印this看到的虚拟地址
  
  this同样能用做在同一个类中，作为另一个构造其中的部分形参的构造器

class text{
	String name;
	int price;
	public text(String name){
		this.name=name;
	}
	public text(String name ,int price){
		this(name);
		this.price=price;
	}
}

重载

方法名一样，但是参数不同
如:
func(int a)
func(double a)

传参

只分为基本类型传参和类传参
对于基本类型传参来说，我们是没有办法对方法外的值做出改变的，因为我们始终传入的是副本，对于类来说我们传入的其引用，此时，如果想要不对原来的值产生影响，需要在类中实现接口Cloneable

class text implements Cloneable{
	String name;
	int price;
	public Object clone(){
		return super.clone();
	}
}
public static void main(String[]agrs){
	text t= new text();
	text kk = (text)kk.clone(;
}

接口与继承

接口就像是一种约定，我们约定某些英雄是物理系英雄，那么他们就一定能够进行物理攻击
实现某个接口，就相当于承诺了某种约定，继承了某种接口就必须实现接口中的函数，可以同时继承多个接口
一般来说使用过程如下

//首先定义两个文件A.class B.class
public class A{
	public void Print();
}
public class B implements A{
	public void Print(){
		System.out.println();
	}
}

java虚拟机

JAVA虚拟机的内存可以分为三个区域：栈、堆和方法区

栈stack

栈描述的是方法执行的内存模型，每个方法被调用都会创建一个栈帧（用于存储局部变量、操作数、方法出口）,JVM为每一个线程创建一个栈，用于存放相关方法的信息
栈属于线程私有，不能线程间共享
栈的存储特性是“先进先出和后进后出”
栈是由系统自动分配，速度快，并且栈是一个来纳许的存储空间

堆heap

堆用于存储创建好的对象和数组
JVM只有一个堆，被所有的线程共享
堆是一个不连续的内存空间，分配灵活，速度慢

方法区

JVM只是一个方法区，被所有的线程共享
方法区实际也是堆，只是用于存储类，常量相关的信息
用来存放程序中永远是不变或者唯一的内容

参数传递

JAVA中的所有

值传递

在方法被调用时，实参通过形参把它的内容传输方法内部，此时形参把他的接收到的内容是实参值的一个拷贝，因此在方法内对形参的任何操作，都仅仅是对这个副本的操作，不影响原始值的内容

JAVA设计模式

单例模式

所谓单例模式，就是对于此类来说，可以，且仅可以有一个实例对象，主要特征如下：
构造方法私有化
私有静态属性指向实例
public static 的 getInstance方法返回第二步的静态属性

又主要分为一下两类模式
一种是饿汉式单例模式，即对于变量刚开始时候就进行初始化，对于其他所有对象来说，唯一一种创建实例的方法即
text t = text.getInstance();

class text{
	private text(){}
	private static text Instance = new text();
	public static text getInstnce(){
		return Instance;
	}
}

还有一种是懒汉式单例模式
与上面的区别是，只有当确实调用该方法的时候才会去创建对象

class text{
	private text(){}
	private static text Instance;
	public static text getInstnce(){
		if(Instance==null){
			Instance = new text();
		}
		return Instance;
	}
}

应用

饿汉式立即加载，无论是否会用到这个对象，都会加载，如果在构造方法里写了性能消耗较大，则不应使用
懒汉式，是延迟加载的方式，只有使用的时候才会加载。 并且有线程安全的考量(鉴于同学们学习的进度，暂时不对线程的章节做展开)。
使用懒汉式，在启动的时候，会感觉到比饿汉式略快，因为并没有做对象的实例化。 但是在第一次调用的时候，会进行实例化操作，感觉上就略慢。