java基础总结
1.JVM,JRE和JDK的区别
- JVM:java的虚拟机，用于保证java的跨平台的特性
- JRE(Java Runtime Environment):java的运行环境,包括jvm+java的核心类库。 、
- JDK(Java Development Kit):java的开发工具,包括jre+开发工具
2.开发的注释
- 单行注释 格式 //
- 多行注释 格式 /**/
3.标识符的命名规则
- 由数据(0-9)，大小写英文字母，以及 下滑线和$符号组成
- 不能数字开头
- 不能以关键字命名
4.数据类型
- 基本数据类型
- 整数类型：byte,short,int,long
- 浮点数类型：float,double
- 字符类型：char
- 布尔类型：boolean(ture false)
- 引用数据类型
- 类
- 接口
- 数组
5运算符
-
加减运算符 ：+，-
- 加减运算符方向从左到右，操作整形或者浮点型数据
-
乘，除和取余 ：*，/ , %
- 方向也是从左到右，操作的整形或者浮点型数据
-
算数表达式
- 用于算数符号和括号连起来的符合java语法规则的式子，称为算数表达式
-
自增自减运算符：++ ，–
- –x 表示使用X之前，先使x的值（减）1；
- ++x表示使用X之前，先使x的值（加）1；
- **x–**表示使用X之后，先使x的值（减）1；
- ++x表示使用X之后，先使x的值（加）1；
-
关系运算符
- 大于号： >
- 小于号：<
- 大于等于：>=
- 小于等于：<=
- 等于：==
- 不等于：!=
6.逻辑运算符
- (&&)符号： 也叫短路与，&&的两侧必须要求是布尔类型（boolean）值或者布尔类型(boolean)表达式
- 例如 int =2，j=4; 则（++i=2）&& (j++=4) 结果为false,因为左侧（++i=2）不成立，为false.程序不会去继续判断右侧表达式的真假了。
- （&）符号：也叫逻辑与，
- nt i = 2，j = 4；则（++i=2）&（j++=4）的结果为false，但是&与&&的执行过程不一样：先判断++i=2是否成立，结果为false不成立，但是程序还是会继续判断下一个表达式是否成立，j++=4,该表达式成立。但是&逻辑运算符要求两侧的值都为真时，结果才为真。
- (||)逻辑或 ：又叫短路或
- (||)与(|)的区别在于，如果||两侧的布尔表达式中，第一个表达式为ture，这个表达式已经为真，则程序不会去执行另一个表达式是否为真、如果第一个表达式为false，程序才回去继续执行右侧的表达式
- int i=0;
if(3>2 || (i++)>1){i=i+1}
System.out.println(i)
最终打印的结果为1，因为第一个表达式3>2为真，就不会去执行第二个判断，就没有i++自增
- (|) 逻辑或：
- 它与||最大的不同在于，|两侧的布尔表达式，程序先执行第一个表达式，但是无论第一个表达式是否为真，程序都会去执行第二个表达式。
- int i=0;
if(3>2 | (i++)>1){i=i+1}
System.out.println(i)
最终打印出来的结果为2，因为无论第一个条件3>2是否为真，程序都回去执行判断第二个表达式，因此i++自增是会被执行，所以最终i=2
6.流程控制
1.顺序结构
1.if语句
-
第一种
if(布尔表达式或者布尔值){ 条件成立执行语句... } -
第二种
if(布尔表达式或者布尔值){ 条件成立执行语句... }else{ 条件不成立执行语句... } -
第三种
if(布尔表达式或者布尔值){ 语句... } else if(布尔表达式或者布尔值){ 语句... } //多重判断，当第一个条件不满足时依次执行下面的条件，当所有的条件都不满足时 else 结束语句 ...//可以有零个或者多个else if语句 else//最后的else语句也可以省略 { 语句... }
2.switch语句
- switch语句会先求expression表达式的值
- 然后拿这个表达式的值和case标签后的值进行比较，一旦相等，程序就会执行case标签后的代码。
- 不在判断与后面的case，注意不要忽略break,没有break就会击穿
- default标签，当所有的case都不满足就走default下的代码
/*
* 定义星期数
* */
int expression=6;
switch (expression){
case 1:
System.out.println("expression = " + expression);
break;
case 2:
System.out.println("expressio = " + expression);
break;
case 3:
System.out.println("expressio = " + expression);
break;
//语句 。。。。
default:
System.out.println("数据大于5");
}
}
2.循环结构
- 一般循环语句可能包含4个部分：
- 初始化语句
- 循环条件
- 循环体
- 迭代语句
- 三种循环之间可以相互嵌套
1.while循环语句
- 只要布尔表达式为true，循环就会一直下去
- 我们大多数情况下会让循环停止下来，我们需要让表达式来结束循环
- 循环条件一直为true就会造成死循环
int i=0; //定义变量
int sum=0; //定义变量
while (i<100){ //布尔表达式条件为true就循环
i++; //
sum=sum+i;
}
System.out.println("sum = " + sum);
2.do while循环语句
- 对于while语句而言，如果不满足条件，不能进入循环，但有时候我们需要及时不满足条件也至少执行一次
- do while 循环和while 相似，不同的是do while至少循环一次
- 区别：while循环在判断，do while 是先执行后判断，do while至少循环一次
int i=0;//定义变量
int sum=0; int i=0;
do {
i++; //自增
sum=sum+i;
}while (i<100); //表达式为true就会循环
System.out.println("sum = " + sum);
3.For循环
- for循环语句是支持迭代的一种通用的结构，最有效，最灵活的循环结构
- 第一步：初始化
- 第二步：检测表达式的值，true 执行 还是false 中止循环
- 第三步：开始循环体后面的语句
- 第四步执行一次循环后，更新循环控制变量 (迭代因子控制循环变量的增减)
for (int i = 0; i < 1000; i++) {
if (i%5==0){
System.out.print( i+"\t");
}
if (i%(5*3)==0){
System.out.println();
}
}
//无限循环
for (; ; ) {
//执行语句
}
4.增强For循环
int[] num={1,2,3,4,5,6};
for (int i : num) {
System.out.println("i = " + i);
}
5.foreach循环语句
ArrayList<String > list = new ArrayList<>();
list.add("来了老弟");
list.add("来了老弟");
list.add("来了老弟");
list.add("来了老弟");
list.forEach(s -> System.out.println("s = " + s));
7.数组
- 简化格式 ： 数据类型 [] 数组名称 ={值，值，。。。。}
- 完整格式： 数据类型 [] 数组名称 =new 数据类型[]{值，值，。。。。}
- 数组是相同类型的有序集合
- 数组的描述就是相同的类型的若干个数据，按照一定的先后循序排序组合而成
//数据类型 [] 数组名称 ={值，值，。。。。}
int [] strings={1,2,3,4,5,6};
// 数据类型 [] 数组名称 =new 数据类型[]{值，值，。。。。}
int [] string=new int[10];
//给数组赋值
string[0]=1;
string[0]=2;
string[0]=3;
string[0]=4;
//取值
System.out.println("string[2] = " + string[2]);
- 数组的特点：
- 长度是确定的，数组一旦创建，他的大小就是不可改变的
- 元素类型必须相同，不允许出现混合类型
- 数组元素可以是任何数据类型，包括基本的类型和引用类型
- 数组属于引用类型，数组也可以看成对象
- java的对象是在堆中的，数组的对象本身在堆中
- 越界 则报 ArrayIndexOutOfBoundsExceptio
8.面向对象
-
什么是类
- 类就是将对象将会拥有的特征(属性)和行为(方法)
-
对象
-
首先要说明一点，对象不是java的，事实上他只是一种概念，一种用于解决问题的程序设计的思想方法
-
在面向对象中把某一类事物所共有的属性和行为抽象出来之后就形成了一个类。 这个例子就叫对象
-
所以从上可以看出类和对象之间存在着这样一种关系：类是具有共同的属性名称和行为的一组对象的抽象，而对象则是一个类的真实的例子。
-
创建对象： 类名 对象名=new 类名()
-
使用对象 ： 对象名.属性 /对象名.方法 名
-
-
成员变量与局部变量
- 成员变量：在类中定义，用来描述对象将要有什么。
- 局部变量：在类的方法中定义，在方法中临时保存数据
-
方法
-
方法的基本形式
-
语法
访问控制修饰符 返回值类型 方法名(形参1，形参2…){ 方法体 } -
分类
无返回值 有返回值 无形参 void 方法名() 返回值类型 方法名() 有形参 void 方法名(需要的参数) 返回值类型 方法名(需要的参数) -
方法的调用
- 对象名.方法名(参数1，参数2，。。。。)
- 方法通过对象名调用，且方法被调用才会执行
- 返回值类型的描述，是在方法调用后计算的结果
- 参数列表给出传给方法的信息类型和名称
- java中的方法只能作为类的一部分来创建
- 方法只能通过对象名调用，除了(static方法的)除外
-
方法 的特点
- 定义方法可以将功能代码进行封装，
- 方法只有被调用的时候才会执行
-
return返回方式
- 你的方法声明返回值数据类型与return 语句返回值的数据类型必须一致
- 当return放在循环体内部时，他的作用不但可以跳出循环体，同时还跳出方法
-
java中的方法传参只有值传递
- 形参是基本数据类型：
- 形参是引用数据类型：
-
-
方法的重载
- 重载的概念
- 在同一各类中聚少有两个同一个名字，但不同参数数据类型列表，这就是方法重载
- 方法重载的三大规则
- 方法名相同
- 参数不同 ： 1.数量不同 ，2类型不同，3顺序不同
- 同在一个类中
- 和返回值无关
- 重载的特点
- 相同的方法名，随着参数的不同编译器会制动的判断调用哪个方法
- 重载的概念
-
-
面向对象得到三大主要特征
-
封装性
-
封装就是把对象成员属性和成员方法结合在一起
-
信息屏蔽，隐蔽对象内部细节，对外形形成一个便捷，只保留有限的对外访问的接口( get()和set()方法 )
-
封装的意义在于保护或者防止代码，被无意的破坏
-
保护数据，不让类以外的程序直接访问或者修改，只能通过提供的公共接口访问( get()和set()方法 )
public class User { private String id; private String name; //名称 private String age; //年龄 //默认有无参构造 但是写了有参构造必须写无参构造 public User(){} // 有参构造 public User(String id ,String name ,String age){ // this.id 表示当前类的成员变量id 而等于id则表示传入的参数 this.id=id; this.name=name; this.age=age; } // get()方法表示获取成员变量的值 public String getId(){ return this.id; } public String getName(){ return this.name; } public String getAge(){ return this.age; } // set()方法给成员变量赋值 public void setId(String id){ this.id=id; } public void setName(String name){ this.name=name; } public void setAge(String age){ this.age=age; } }
访问权限
访问权限 本类 同包 不同包，子类 不同包，非子类 public 可以 可以 可以 可以 private 可以 protected 可以 可以 可以 默认 可以 可以 -
-
继承性
- 继承：是面向对象的一种概念，如果有一个类A继承另一类B,就把A称为B的子类，而B称为A的父类
- 继承可以使得子类具有父类的各种属性和方法，
- 继承性是子类继承父类不是private修饰的成员作为自己的成员变量，也不是private修饰的方法作为自己的方法，继承的方法和成员变量访问权限保持不变
-
java中只有单继承，多实现
- 继承是类与类之间的关系：依赖，组合，聚合
- 子类继承父类，使用关键字extends来表示
如下代码
//子类继承父类 public class A extends B { public void show(){ System.out.println("来了小老弟"); } } //父类 class B{ public void show(){ System.out.println("来了小老弟"); } }-
this：调用者本身
-
super:调用父类方法，属性 ，前提只能在继承条件下使用
-
方法的重写：当子类不重写父类的方法，调用父类的方法只能调用父类的，子类重写了父类的方法，执行的是重写的方法
代码如下
public class Test { public static void main(String[] args) { A a = new A(); a.B1(); a.A1(); } } //子类继承父类 class A extends B { @Override public void B1() { //重写父类的方法 System.out.println("我是A"); } public void A1(){ System.out.println("我是A"); } } //父类 class B{ public void B1(){ System.out.println("我是B1"); } }
-
多态性
-
多态指是同一个方法的调用，由于对象不同可能会有不同的行为
-
多态是方法的多态，3个必要的条件，继承，方法重写，父类指引像子类
-
父类引用指向子类对象后，用该父类引用调用子类子类重写的方法，此时多态就出现了
代码如下
//父类 public class Animal { public void show(){ System.out.println("叫了一声"); } } //子类继承父类 class Dog extends Animal{ @Override public void show() { //方法的重写 System.out.println("汪汪"); } } //子类继承父类 class Cat extends Animal{ @Override public void show() { System.out.println("喵喵"); } }测试代码
public class Test { static void Test(Animal animal){ animal.show(); } public static void main(String[] args) { Dog dog = new Dog(); Test(dog); Cat cat = new Cat(); Test(cat); /* * 测试结果 * 喵喵 * 汪汪 * */ } }
-
-
9.抽象类与接口
-
抽象方法
- 使用abstract修饰的方法，没有方法体，只能声明，定义一种 “规范” ,告诉子类必须实现抽象方法
-
抽象类
-
包含抽象方法的类就是抽象类，通过abstract方法定义规范，然后要求子类必须定义具体的实现，通过抽象类，我们可以坐到严格限制子类的设计，使子类之间更加通用
-
抽象类不能实例化，不能用new来实例化对象
-
抽象类可以包括属性，方法，构造方法，但是构造方法不能new实例对象
-
抽象类智能被继承
-
抽象方法必须被子类实现
代码如下：
public class abstractTest { public static void main(String[] args) { Dog cat = new Cat(); //编译看左边，执行看右边 cat.show(); System.out.println("cat.i = " + cat.i); } } //父类 abstract class Dog{ // 抽象方法 abstract public void show(); int i=1_0000_0000; //定义常量 } //子类继承父类 class Cat extends Dog { // 方法的重写 @Override public void show() { System.out.println("汪汪" ); } }
-
-
接口
- 接口就是规范，定义一组规则，体现现实世界，
- 比如：如果你是天使，则必须能飞，如果你是汽车，就必须能跑，如果你是坏人，就必须欺负好人，如果你是一辆公升级重机，就必须跑299km/h
- 简单的说，他就是契约，向我们人间法律一样，制定好后大家遵守
-
接口的作用
- 接口比抽象类还抽象，可以更加规范的对子类进行约束，全面的专业实现了：规范和具体实现的分离
- 从接口的实现者的角度看：接口的定义接口定义可以向外部提供服务
- 从调用者的角度看，接口定义实现者能提供的那些服务
-
非静态内部类
要点:
- 非静态内部类可以直接访问外部类的成员
- 但外部类不能访问费静态内部类成员
- 费静态内部类不能有静态方法，静态属性和静态初始化块
成员访问要点：
- 内部类方法的局部变量： 变量名
- 内部类属性：this.变量名，
- 外部属性：外部类名.this.变量名。
代码如下：
public class User { private String name; //定义属性 //内部类 class A{ public void show(){ String name = User.this.name; //访问外部类的成员属性 } } }6.静态内部类
要点：
- 静态内部类可以访问外部的静态成员，不能访问外部类的普通成员
- 静态内部类看做外部类的一个静态成员
代码如下：
public class User { private String name; //定义属性 static class A{ } }
关键字
- static
- 该类公用变量，属于类，被该类共享，在类被载入是初始化
- 对于该类所有的对象来说，static成员变量只有一份，被该类的所有对象共享
- 用类名来调用
- final
- 修饰变量：被他修饰的变量不可改变，赋值后就不能重新赋值
- 修饰方法：该方法不能被子类重写，可以被重载
- 修饰类：修饰的类不能被继承，比如String Math等
- final
8171
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
