1.开发环境的搭建
a)下载安装JDK
b)JDK—java develop kitjava开发工具包
JDK中包含JRE
c)JRE—java runtime environmentjava运行时环境
2.配置环境变量
3.第一个java程序
public class HelloWorld{// 一个公有类HelloWorld
public static void main(String[] args){// 程序的入口
System.out.println(“Hello World”);// 输出一句话
}
}
开始运行CMD，切换到D盘目录下，
运行javac HelloWorld.java
我们会在D盘个目录下发现生成一个HelloWorld.class字节码文件，然后再运行java HelloWorld，得到程序运行后的结果
一个源文件中，至多有一个公有类，若一个源文件中有公有类，那么这个源文件的名字就必须和这个公有类名一致，若源文件没有公有类，那源文件的名字不需要和任何一个类的名字一致
公司编码规范：一个源文件中必须有公有类
类库文件都是以jar结尾的，所以我们一般称它为架包。
IDE开发工具
–Eclipse—免费
SRC工程的源码目录
我们在SRC目录下一般不直接写我们的源文件，先建包，包就是一级一级的目录，我们在包目录下编写我们的源文件
Java块
1.定义类的块称为类块，定义方法的称为方法块，我们所有的变量，方法等都在块中声明和定义。
2.标识符的命名规则
类 —– 所有单词的首字母大写
方法、变量 —- 第一个单词首字母小写，其余单词首字母大写
包名 —- 全小写
常量 —- 全大写
3.数据类型及分类
基本数据类型：1)数值型：a.整型(byte,short,int,long)
b.浮点型(float,double)
2)字符型(char)
3)布尔型(boolean)
引用数据类型：数组，接口，类
4.变量定义在方法块中必须要初始化才能使用
5.变量的三大要素：数据类型，名称，作用域
作用域越小，优先级越高
强类型语言：
变量使用前一定要声明，并且初始化；
变量一旦声明，类型不可变；
相同的作用域不能定义重名变量；
声明明确的数据类型。
6.三大特性，封装，继承，多态
====================================================
数据的原码、反码、补码
[+1] = [0000 0001]原=[0000 0001]反=[0000 0001]补
[- 1] = [1000 0001]原=[1111 1110]反=[1111 1111]补
计算1-1
原码计算
[+1+(-1)] = [0000 0001]原+[1000 0001]原=[1000 0010]原=-2
反码计算
[+1+(-1)] = [0000 0001]反+[1111 1110]反=[1111 1111]反
=[1000 0000]原=-0
问题:首先0是不该有符号的，其次表示0的原码就有两个了，分别是[0000 0000]和[1000 0000]，这就歧义了
补码计算
[+1+(-1)] = [0000 0001]补+[1111 1111]补=[0000 0000]补
=[0000 0000]原 = 0
补码的计算解决了正负0的问题，同时还解放了[1000 0000], [1000 0000]就用来表示-128了
数据类型转换
自动数据类型转换
1.两种类型彼此兼容
2.目标数据类型范围大于原类型数据范围
5
0000 0101
3
0000 0011
==========
0000 0110 6
按位与
0000 0001
按位或
0000 0111
异或
0000 0110
=================================================
If(条件表达式){
}
If(条件表达式){
}else{
}
If(条件表达式1){
}else if(条件表达式2){
}else if(条件表达式3){
}
Switch(表达式)//注意代码冗余(表达式的数据类型只能是int、byte、short、char)
Case 表达式值1：
Do something;
Break;
Case 表达式值2：
Do something;
Break;
Default:
Do something;
For循环
Do while循环
While循环
数组
1.数组的声明
数组类型[] 数组名称
数组类型 数组名称[]
a)int[] array;
b)int array[];
声明数组时，不能指定长度
2.数组的创建
数组名称 = new 元素数据类型[元素个数];
array = new int[5];
创建数组的时候，必须指定长度
多维数组s
int a[][] = new int[3][];
{1,2,3,4} {5,6,7} {8,9}
定义方法
此处的int为方法的返回值类型
square是方法的名字
x是square方法的形式参数，int是形式参数的类型
public static int square(int x){
int y = x*x;
return y;
}
return 除了可以返回数据之外，还能结束方法的运行，在void方法中，也是可以使用的，它的意义就仅剩结束方法的运行。
面向对象编程思想：就是以人类的正常思维去分析、设计以及编码的一种思想
抽象
类：生成对象的模板，它用来描述一类群体
属性：属性用来描述这类群体的特征，定义在类块当中（全局变量或者成员变量），全局变量有默认值。
注意：只有引用数据类型的值可以为null
方法：用来描述这类群体的行为
这些属性和方法又叫对象属性、对象方法
对象：用来描述具体的一个个体
构造器/构造方法
构造方法作用：它是给对象属性初始化的
构造方法是这样的方法：
1.首先，方法的名字必须和类名一致；
2.构造方法可以有参，也可以无参；
3.构造方法一般都是public的
4.构造方法没有返回值，连void也不可以写。
实例化对象有两个必不可少的步骤：
1.在内存当中开辟内存空间存储对象
2.调用构造方法给对象初始化
如果我们在类中没有定义任何的构造方法，系统会自动给这个类分配一个空的、无参的构造方法；如果这个类已经定义了构造方法，系统就不会自动分配了。
的地方，子类一定可以出现，子类必须能够完全替代其父类所有特征和行为的情况下，这两个类才有继承关系。
继承是代码重用的一种重要手段，它还是达到开闭原则的基础。
开闭原则：对拓展开放，对修改关闭。
代码重用不是继承最大的优点，它的最大优点是拓展。
【子类不能继承父类的构造方法】
【子类不能继承父类的私有成员】
实例化的过程：
如果一个类有父类，在实例化的过程当中，先实例化父类对象，然后实例化子类对象，子类构造方法默认调用的是父类的无参构造方法实例化的对象，如果父类当中没有无参的构造方法，子类就必须显式调用父类的其他有参构造方法
super关键字
代表父类对象
super()—>父类的无参构造方法,只能使用在子类当中，并且在子类构造方法内只能使用一次，且只能使用在第一行
===============================================
包
com.neuedu.chapter1一级一级文件夹
导入包
import 包名.类名
//7包下Student类对象
Student s = new Student();
//6包写Student类对象
com.neuedu.chapter6.Student s1 = new com.neuedu.chapter6.Student();
==========================================
封装
public
protected
friendly default(默认的)
private
修饰类
public friendly 可以修饰类
public:公有的，在工程当中都能看到的，一个类至多有一个公有类，可以有多个非公有类，如果有公有类，源文件的名字必须和这个公有类名字一样，若一个源文件没有公有类，源文件的名字就不需要和任何一个类的名字相同。
protected private 不能修饰
friendly：默认的，一个源文件当中可以有多个访问权限符是默认的类
修饰属性、方法
修饰属性、方法 public protected 默认的 private
当前类 可见 可见 可见 可见
相同包的类 可见 可见 可见 不可见
相同包的子类 可见 可见 可见 不可见
不同包的类 可见 不可见 不可见 不可见
不同包的子类 可见 可见 不可见 不可见JavaBean 就是一个普通的类，但是需要满足三个条件
1.所有属性全私有；—- 保护属性的作用
2.有无参构造方法；—- 跟框架相关
3.有公有的get、set方法。—- get方法获取属性，set方法为属性赋值
方法的重写：
发生在子类当中，方法名称一样，参数列表一样，返回值类型一样，子类重写方法的访问权限符不小于父类被重写方法。
=====================================================
重载（编译时多态）和重写（运行时多态）的区别？
重载发生在同一个类当中，重写发生在子类当中；
重载方法名相同，参数列表必须不同，返回值类型可以相同可以不同
重写方法名称一样，参数列表一样，返回值类型一样，子类重写方法的访问权限符不小于父类被重写方法。
=====================================================
多态（解耦合）
1.字面意义：一个事物的不同形态
2.编码意义：一个方法的不同实现
3.设计意义：把做什么和怎么做分开
多态的前提
1.有泛化关系（继承或实现）
2.有方法的重写
3.有父类引用指向子类对象（上溯造型）
多态优点：解耦合，提高了程序的可维护性、灵活性和拓展性
开闭原则是绝对的
静态static
Static 可以修饰属性，用Static修饰的属性，可以直接用
类名.属性名 直接访问
属性和方法我们说必须要通过对象才能访问，但静态变量直接可以通过类名.属性名直接进行访问，所以静态变量的存储位置就不在堆区当中，而是在方法区中的静态区。（静态区存储静态属性）
静态属性对所有类对象都是共享的
Static 可以修饰方法—静态方法
静态方法只能访问静态变量，不能访问非静态变量，因为访问非静态变量需要对象，而静态方法的访问不需要对象。
Static{
//静态块
}
单例模式
保证一个类只有一个实例
1.因为实例化对象需要调用构造方法，那么我们只要让这个构造方法不可见就行构造方法私有化
private Singleton(){
}
2.在这个类中实例化一个私有的、静态的类对象。
private static Singleton s = new Singleton();
3.构造方法私有化之后，得有一个返回这个类对象的方法，这个方法是公有的、静态的、返回值类型是当前类对象类型的（但不能是 return new Singleton();）。
public static Singleton getInstance(){
//错的
//return new Singleton();
return s;
}
final—最终的
修饰属性:代表常量，在整个程序运行过程中不可变，系统不会自动给它赋初始值，所以必须手动赋值。
在方法中用final定义常量时，可以在声明时不赋初始值，一旦赋值只能赋值一次
修饰方法：用final修饰的方法不能被重写。如果想在众多方法中保护一个或几个方法的时候，可以用final修饰。
修饰类：最终的类，不能被继承。
抽象
修饰方法：
抽象方法,用abstract修饰，抽象方法没有实现，也就是说抽象方法没有方法块
public abstract void h();
如果一个类当中有抽象方法，那么这个类就必须是抽象类（反之不成立）
如果一个类当中有抽象方法，那么这个类的子类，必须实现这个抽象方法，除非这个子类也是抽象类。
抽象类不能实例化对象—-所以它的作用就只剩被继承了。
抽象方法不能用static修饰。
什么样的类适合定义成抽象类？
因为抽象类作用只是被继承了，所以父类适合定义成抽象类。
能否用final和abstract同时修饰一个类？
不能，抽象类作用是被继承，final类不能被继承，一个类不能实例化对象又不能被继承，这个类就彻底失去意义了。
接口interface
如果一个抽象类当中的方法全都是抽象方法，那么这个类就是纯抽象类，纯抽象类可以定义成一个接口。
问题：接口是不是类？
接口不是类
特点：
1.抽象类中可以包含非抽象方法，但接口中的方法必须是抽象方法。
2.接口中的变量默认是public static final的
接口中的方法默认是public abstract的
3.接口也不可以实例化对象
4.一个类可以实现接口（implements）
如果一个类实现了接口，这个类就必须实现这个接口中所有的抽象方法，除非这个类是抽象类。
5.为什么要用接口？
类的继承是单继承，一个类最多只有一个父类，接口就是用来弥补单继承的缺点的，因为接口是可以多实现的。
6.我们通常用类描述一类群体，用接口描述一类角色。
如果一个类既有继承，又有实现，继承在前，实现在后。
7.类和类之间是继承关系，并且是单继承。
类和接口之间的关系是实现，一个类可以实现多个接口。
接口和接口之间是继承关系，一个接口可以继承多个接口。
8.接口和抽象类的区别
接口当中只包含常量和抽象方法，抽象类中可以包含非抽象方法，类可以实现多个接口，但只能有一个父类，接口之间可以多继承
内部类
内部类就是在一个类中内部的类，它严重破坏了良好的代码结构，但为什么要用它？因为它能随意的访问外部类的所有成员，包括私有的成员。
内部类可以用public、protected、默认的、private去修饰，并且这个内部类可以是静态的。
工具类
Java当中为我们提供了API，API当中包含了大量的开发中所需要的包。
类的全限定名包名.类名
1.java.lang 这个包不需要导入就可以直接使用