程序 = 算法+数据结构
算法：解决问题的步骤
数据结构：将数据按照某种结构来保存
好的数据结构 => 好的算法
char 可以存储一个中文字符（1个char是两个字节，一个中文字符也是两个字节）
&& 短路 常用
三目运算
int a = 1;
int b = 2;
int c = a > b ? c =0101 : c = 1010
boolean ？ 1：2
-- ++ 单独使用在前在后没有差别
使用时在前在后有差别
++ 在前 先自增在使用
++ 在后 线使用在自增
关系运算 < > <= >= == != 返回结果是boolean
逻辑 建立在关系运算的基础之上 结果也是boolean 有短路 和不短路，而&则是会把两边的表达式都执行完
&& 与
|| 或
！非
+ 号 两边都是数字做加法运算
一边是字符串做连接
switch case 常常和 break 一起用
清晰，效率高
java7.0以上 switch case 可以使用 字符串
变量的作用域 从声明开始到包含它最近的大括号
三要素：
1/循环变量的初始化
2/循环的条件（以循环变量为基础）
3/循环变量的改变（向着循环的结束变）
for(int i = 1; i<10;i++){
System.out.println("good");
}int i = 1;
while(i < 10){
System.out.println("good");
i++;
}int i =1;
do{
System.out.println(i+"good");
i++;
}while(i<10);第一要素和第三要素一样的时候用do while
循环中使用break 或者 continue
循环能用一层就不用两层
能用两层就不用三层
需要4层-设计是不是有问题
循环的层数越少越好
嵌套循环执行：
外层一次，内层所有
Math.random() 生成一个0-1之间的数 包含0不包含1
把它*8或者 *100 就是 0-8之间的数 0-100之间的数
再次使用强转 ： 除去小数位 (int)(Math.random()*10)
数组就是最基本的数据结构
相同数据类型的元素
数组按线性顺寻一个跟一个
数组也是一种数据类型
声明
int[] arr;
初始化
arr = new int[4];
声明+初始化：
int[] a = new int[4];
声明了一个整形数组a，可以存储4个整数，默认值是 0
int[] arr = {1,2,3,4,5,6};
int[] arr = new int[]{1,2,3,4};
访问数组
int[] arr = {1,2,3,4,5,6};
arr[1]
数组的遍历
for(int i = 0;i<arr.length;i++){
System.out.println(arr[i]);
}
数组的复制
System.arraycopy(源数组,开始复制的下标位置,目标数组，目标数组的下标位置,复制的个数)
复制 扩容(copy的灵活性差一点)
int[] arr = {1,2,3,4,5,6,7,8,9};
int[] arr_1 = Arrays.copyOf(arr,6);
int[] arr = {1,2,3,4,5,6,7,8,9};
a = Arrays.copyOf(a,a.length+1);
数组的排序
Arrays.sort()
冒泡排序，两个for 循环 控制 一个 if 比大小
//冒泡算法（从小到大）
System.out.println();
int[] arr_6 = new int[100];
for(i = 0;i<arr_6.length;i++){
arr_6[i] = (int)(Math.random()*1000);
}
for(i = 0;i < arr_6.length-1;i++){//轮数 循环， 总轮数为 数组个数-1（从0 开始）
for(int j = 0; j< arr_6.length-1-i;j++){//每一轮比多少次，循环，为总轮数 - 第几轮（从0 开始）
if(arr_6[j] > arr_6[j+1]){//判断 从小到大 还是从大到小
int t = arr_6[j];
arr_6[j] = arr_6[j+1];
arr_6[j+1] = t;
}
}
}
for(i = 0; i< arr_6.length;i++){
System.out.print(arr_6[i]+" ");
}
//冒泡算法（从大到小）
Random randOne = new Random();
System.out.println();
int[] arr_7 = new int[100];
for(i = 0;i<arr_7.length;i++){
//arr_7[i] = (int)(Math.random()*1000);
arr_7[i] = randOne.nextInt(1000);
}
for(i = 0;i < arr_7.length-1;i++){
for(int j = 0; j< arr_7.length-1-i;j++){
if(arr_7[j] < arr_7[j+1]){
int t = arr_7[j];
arr_7[j] = arr_7[j+1];
arr_7[j+1] = t;
}
}
}
for(i = 0; i< arr_7.length;i++){
System.out.print(arr_7[i]+" ");
}
}方法 函数 过程
方法是用于封装一段特定的逻辑功能
方法尽可能的独立也就是只干一件事情.
修饰词，返回值类型，方法名，参数列表，方法体
public static void set(String name,int age){
}
public static int get(){
}
public class MathDemo {
public static void main(String[] args){
say();
say("lmdtx");
say("hi","xx");
int n = add(1,2);
System.out.println(n);
System.out.println(plus(1,2));
int x = 2;
int y = 3;
int sum = plus(x,y);
System.out.println(sum);
}
public static void say(){
System.out.println("Hello World!");
}
public static void say(String name){
System.out.println("Hello " +name+"!" );
}
public static void say(String whatAreYouSay ,String name){
System.out.println(whatAreYouSay+" "+name+"!");
}
public static int add(int a,int b){
int c = a+b;
return c;
}
public static int plus(int a, int b){
return a+b;
}
}1设计数据结构-变量
2设计程序结构-方法
3设计实现-方法的实现
面向对象：以对象为核心，对着对象操作
先找对象，再找类
在代码中是 先创建类，在创建对象
创建对象：
类名 引用名 = new 类名()
创建类：
class 类名{}
一个类可以创建多个对象，结构相同，数据不同.
类就是一中数据类型
不创建对象，类就没有意义了
包含
对象所共有的特征
对象所共有的行为
成员变量
方法
对象创建后，其成员变量可以按照默认的方式来初始化
初始化对象成员成员变量时，其默认值的规则：
数值类型： 0
boolean：false
char： /u0000
引用类型：null
如何 设计：
1：找对象
2：抽类
3：设计类
3.1：成员变量
3.2：方法
类定义后，使用new 创建对象，创建对象的过程通常称为实例化
在内存中：
栈：局部变量在栈中
基本类型 是值
引用类型是 堆中的地址
堆：对象都在堆中
引用类型变量之间的复制不会创建新的对象，但是可能会使两个以上的引用指向同一个对象
引用类型 可赋值 null，表示还没有指向对象 这个时候访问对象的成员变量或者调用方法的时候会有空指针异常（NullPointerExcrption）
方法的签名
方法名；参数列表
一个类中，不可以有两个方法的签名完全相同
方法的重载
方法的名称相同，但参数列表不同.(方法的签名不同)
java 建议：
1个文件1个类
java 规定：
1个文件可以有多个类
但是只能有一个public 类
编译时根据签名绑定调用方法
构造方法
构造方法还是方法，是方法就可以重载，也可以互相调用
对成员变量初始化
与类同名，没有返回值类型（不写void）
构造方法是在创建对象时被自动调用的
不写，编译器默认给一个无参构造
写了，就不提供无参构造
调用构造器
|
Cell cell = new Cell();
this:
this 指代当前对象， 谁调指的就是谁
用法：
this.成员变量
this.方法()
this() 调构造方法
引用类型数组：
Student[] s = new Student[4];
s[0] = new Student();
s[1] = new Student();
s[2] = new Student();
s[3] = new Student();
Student[] s = {new Student(),new Student(),new Student(),new Student()};
声明int[] 类型的数组，名为arrs,包含4个元素，每一个元素默认值为null
int[][] arrs = new int[4][];
int[][] arrs = new int[3][4]
3行，4列
数组是引用类型，对象存在堆中
引用类型数组 new 之后 每一个元素的初始值是null
JVM 内存管理：
堆 存贮 new 出来的对象（包括成员变量）
成员变量的生命周期：创建对象时存在，对象回收时消失
访问对象需要依靠引用变量
当一个对象没有任何引用时，九江市废弃的对象，属于被回收的范围，这个对象中的所有成员变量也被回收
成员变量的生命周期为：从对象在堆中创建开始到对象从堆中被回收结束
垃圾回收机制
垃圾回收器（GC） 是jvm 自带的一个线程，用于回收没有任何引用指向的对象
内存泄漏：不再使用的对象，未被及时回收。
一些对象不用了，但是还没有被及时的回收
严重的内存泄漏会因过多的内存占用而导致程序的崩溃
因此 当确定对象不再使用时，应该及时将其引用设置为null
垃圾回收器：垃圾回收器不定时回收没有引用指向的对象
System.gc()方法.
GC的回收是透明的 ， 并不一定是一发现垃圾 就立刻回收，
一般 当我们需要GC 立刻回收无用 对象，可以调用System.gc()方法
System.gc()用于建议jvm 马上调度gc 回收 但是具体的实现还是取决不同的Jvm
栈（堆栈） 用于存贮 所有 局部变量
在java中，调一个方法，栈中给该方法分配一个“栈桢”（空间）
栈桢 中存 局部变量
方法调用结束，栈桢消失，局部变量也消失
方法区 用于存放类的信息（.class 和 方法）
java 程序运行时 首先通过类装载器载入类文件的字节码信息，经过解析后 装入方法区 类的各种信息（包括方法都在方法区存贮）
方法只有一份，通过this区分对象
继承
父类 共有的 成员变量和方法
子类 特有的 成员变量和方法
关键字：extends
泛化 先写 子类 再写父类
特化 先写 父类 再写子类
一个类只能继承一个父类
但是一个父类可有多个子类
继承有传递性
构造子类之前必须先构造父类：
子类的构造器中第一行有一句super() 不写默认添加 用于调用父类的无参构造方法，如果父类没有无参构造器 就需要自己写super(参数), 必须在子类构造器的第一句。
父类类型引用指向子类的对象 向上造型，但是通过父类的引用，只能访问父类所定义的成员，不能访问子类扩展的部分，类型决定 方法和成员变量 不看对象
让子类公用一中类型 - 父类型
方法重写：
两个类 子类父类
子类和父类方法签名相同
子类重写了父类的方法
当方法被重写时，调用那个方法 看对象
在子类中 使用super.xx() 调用父类的xx方法
子类的权限必须大于等于父类
overload 重载 编译
在一个类里面 方法名相同，参数列表不同
重载的时候看类型 决定 方法和成员变量
override 重写 运行
重写看对象 决定方法和成员变量
在两个类中，子类父类 方法签名相同 子类重写了父类的方法 可以用super 访问父类的方法
package 关键字
用包 解决命名冲突 一般是域名到写 所有字母小写
域名反写.项目名.模块名.类名
在开发大型的工程的时候，需要“数据字典”——常用的字符串、常量等等全部都定义在数据字典中。
import
import 全局限定名
包名+类名
import java.util.*; 不建议...影响性能
访问不同包的时候需要import
不用也是可以得，就是要用全局限定名
封装
对外提供可调用的稳定的功能；
封装容易变化的
public 修饰的成员变量和方法可以在任何地方调用
private 修饰的成员变量和方法 只能在本类中调用。
protected 子类和同包中的类 通常用于保护数据只被子类使用
默认 同包类
类中的成员变量一般用private
方法用public
类 的修饰 pubilc 和默认
protected 和private 内部类
局部变量不需要访问修饰符
static 关键字
修饰成员变量 不属于对象的数据结构
static 变量是类的变量，使用 类名来引用（一般，用对象.也对但是不用） 放在方法区 方法区里面的东西只有一份
某个数据被所有对象公用的时候就用static
成员变量
实例变量 对象 堆中 一个对象一份 不用static 修饰的
静态变量 类 方法区中 所有对象公有一个 static 修饰的
修饰方法：
类的方法中，需要对 对象的实例变量进行操作
类的普通方法中，有this
、 类的静态方法没有this 只能访问static变量
static 块 属于类的代码块
在类加载期间执行的代码块，在创建对象之前
只执行一次，可以用来在软件中加载静态资源（图片 音频 视频）
类只加载一次 到方法区
final 关键字
修饰的就是不可改变的
修饰变量： 不可改变
有两种方法初始化
声明同时初始化
构造器重初始化
findl 关键字也可以修饰局部变量，使用之前初始化即可
修饰方法：
方法不能被重写
防止子类在定义新方法时造成 意外修改 父类的方法
修饰 类
不能被继承
但是可以继承别人
可以保护类不被继承修改，可以控制滥用继承对系统造成的危害
static final
常量，必须声明同时初始化，不可改变
常量 名 全大写
类名.NUM 访问
public static final in NUM = 10；
编译时，直接替换为值
效率高
抽象
abstract
抽象类
抽象方法
抽象方法没有方法体（方法不完整）
abstact void print();
包括这个方法的类 也就不完整了
abstact Print{}
都不完整了，就不能创建对象了（实例化）
一般需要被继承
包含抽象方法的类，必须是抽象类
子类继承 抽象类 的时候 要重写 抽象类中的抽象方法
abstract 和final 不能同时修饰一个类
一个类没有抽象方法，也可以定义为抽象类
同样也不可以实例化
抽象类的意义：
为子类提供一个公共的类型
封装子类的重复内容
定义抽象方法，子类不同的实现
接口：
标准 规范
interface 接口名{}
接口中只能包含常量和抽象方法
接口不能实例化-他里面的方法全是抽象的
只能被实现（也就是子类来继承）
implements
子类实现接口，需要将所有抽象方法都实现
一个类可以实现多个接口 用 逗号分隔
一个类有想继承一个类 有想实现一个接口
就要先继承类 在实现类
接口类型的变量可以引用实现了该接口的类的对象， 通过该变量可以调用该接口中定义的方法
也就是 向上造型
interface Inter{
public static final int NUM = 5;
int NUM2 = 5;//默认添加public static final
public abstract void show();
void show2();//默认有public abstract
}
class Aoo implements Inter{//Aoo 这个类实现了Inter 这个接口，就是Aoo 这个类遵守Inter这个接口的规范
public void show(){
}
public void show2(){
}
}
class Boo{
}
class Coo extends Boo implements Inter{
//先继承，在实现
}
多态
同一类型的引用 指向不同的对象有不通的实现
同一个对象那个，造型不同的类型时，会有不同的功能
向上造型
一个类的对象可以向上造型的类型：
父类的类型
他实现的接口类型
强制转型
强转： 看对象的类型 ===》 new 类名（）
父到子：前提 对象是子
变量 指向的对象 是该子类的类型
转为接口：前提 对象 实现了该接口
变量 指向的对象 实现了这个接口
强壮失败 会有异常 ClassCastException
通过instanceof 解决
语法： 引用 instanceof 数据类型 返回boolean类型
内部类
一个类定义另外一个类的里面，定义在类内部的类 Inner 请所在的类为 Outer
一个类只被一个类使用个，对外部可见，就可以做成内部类
内部类对象通常只在外部类中被创建
内部类中可以直接访问外部类的所有成员
匿名内部类
如果在一段程序中需要创建一个类的对象 （通常这个类需要实现某个接口或者继承某个类）而且对象创建后 这个类的价值也就不存在了，这个类可以不给名字，就是匿名内部类
SuperType obj = new SuperType(){
};
面向对象：
3大特征
封装：保证安全
类 数据 和行为的封装 作为一个整体操作
方法 功能的实现的封装 隐藏实现的细节
访问修饰符 控制访问权限 保证数据的安全
继承：实现代码的重用
extends
多态：提高可维护性，可扩展
多种形态，在继承的基础之上
一个类型指向不同对象，有不同的实现
同一个对象操行成不同类型时，有不同的功能
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
