Java进阶笔记01
进阶20.4.30-20.5.1
- java语言特性 加载与执行
- 可移植性
- 健壮性
- 加载执行
- pubilc class与class
- return break continue
- 面向对象
- Switch
- 方法的递归
- 方法的使用
- 数据结构 算法
- 冒泡排序
- 选择排序
- 折半查找
- 栈
java语言特性 加载与执行
可移植性
JDK java工具箱
JRE 运行环境
JVM java虚拟机
健壮性
JVM自动垃圾回收 不用手动释放
加载执行
编译阶段：
.java编译.class
运行阶段：
.class装载到JVM虚拟机 虚拟机编译成二进制
环境变量 Windows 搜索path
javac 是编译文件 javac d:…
需要编译带包名的.java文件 javac -d . ***.java
java 是运行文件 跟类名 java HelloWord
需要运行带包名的.class文件 java ***.***.***.HelloWord
pubilc class与class
.java文件 可以有多个class 可以没有pubilc class
如果有 只能有一个 并且跟文件名保持一致
return break continue
return: 结束整个方法
break：结束当前离他最近的循环
continue:结束本一次循环 直接进入下一次循环
break可以指定结束某个循环
退出名字为abc的循环:
abc:for(){
for(){
if(){
break abc;
}
}
}
面向对象
面向过程（蛋炒饭）
面向对象（盖饭）
面向对象的特征：封装 继承 多态
Switch
public class switchtest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
double a=11.1;
int b=(int) (a/10);
switch (b){
case 1:
System.out.println("10-19");
break;
default:
System.out.println("2");
}
}
}
方法的递归
public class Test {
/**
* @param args
*
* 递归就是方法自己调用自己
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int n=5;
System.out.println(A.method(n));
System.out.println(B.method2(n));
}
}
//1-N的和
class A{
public static int method(int s) {
if(s==1){
return 1;
}else{
return s+method(s-1);
}
}
}
//1-N的阶乘
class B{
public static int method2(int s) {
if(s==1){
return 1;
}else{
return s*method2(s-1);
}
}
}
方法的使用
public class Method {
/**
* @param args
*
* class 类的使用
*/
public static void main(String[] args) {
method1();//可以省略类名. 因为在本类中调用
a.metho2();//这里不能省略a. 因为不在本类
System.out.println(a.metho(0));//方法的重载使用
System.out.println(a.metho(null));//方法的重载使用
}
// 方法的定义
public static void method1(){
System.out.println("111");
}
}
class a{
public static void metho2(){
System.out.println("222");
}
// 方法的重载 返回值不同 类型不一样 个数不一样 顺序不一样 都可以构成重载
public static int metho(int i){
return i;
}
public static String metho(String i){
return i;
}
}
数据结构 算法
冒泡排序
public class test {
/**
* @param args
*
* 冒泡排序
*
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int arr[]={10,2,4,60,3};
for(int i=arr.length-1;i>0;i--){
for(int j=0;j<i;j++){
if(arr[j]>arr[j+1]){
int temp;
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
for(int i1=0;i1<arr.length;i1++){
System.out.print(arr[i1]+"-");
}
}
}
选择排序
public class test {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int arr[]={2,3,10,1,9};
for(int i=0;i<arr.length-1;i++){
int min=i;
for(int j=i+1;j<arr.length;j++){
if(arr[min]>arr[j]){
min=j;
}
}
if(min!=i){
int temp;
temp=arr[min];
arr[min]=arr[i];
arr[i]=temp;
}
}
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
}
折半查找
public class test {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int i[]={1,2,3,4,5,6,7,8,9,10};
int destElement=10;
int index=binarySearch(i,destElement);
System.out.println((destElement==-1)?"不存在":"下标是"+index);
}
private static int binarySearch(int[] i, int destElement) {
// TODO Auto-generated method stub
int begin=0;
int end=i.length-1;
while(begin <= end){
int mid=(begin+end)/2;
if(i[mid]==destElement){
return mid;
}else if(i[mid]<destElement){
begin=mid+1;
}else if(i[mid]>destElement){
end=mid-1;
}
}
return -1;
}
}
栈
1.方法在调用的时候才会在内存中分配空间
2.没有调用是不会分配空间
3.方法在调用的时候在’栈’中分配空间。（JVM内存中有一块是栈内存）
4.方法调用就是进栈
5.方法结束就是出栈