Java复习笔记
一、 cmd编译,cd进入文件路径,javac 项目名.java,
执行:java 项目名
二、 编码标准 定义包名:com/cn等等.企业名
定义类名:开头大写字母+英文名_大写字母_方式
三.
编译版本与执行版本不一致
基本数据类型
1.四种整数类型(byte、short、int、long):byte:8 位,用于表示最小数据单位,如文件中数据,-128~127
short:16 位,很少用,-32768 ~ 32767
int:32 位、最常用,-231-1~231(21 亿)
long:64 位、次常用
注意事项: int i=5; // 5 叫直接量(或字面量),即直接写出的常数。
整数字面量默认都为 int 类型,所以在定义的 long 型数据后面加 L或 l。小于 32 位数的变量,都按 int 结果计算。
强转符比数学运算符优先级高。见常量与变量中的例子。
2.两种浮点数类型(float、double):
float:32位,后缀 F 或 f,1位符号位,8位指数,23位有效尾数。
double:64 位,最常用,后缀 D 或 d,1位符号位,11位指数,52位有效尾
注意事项:二进制浮点数:1010100010=101010001.02=10101000.10210(2次方)=1010100.010*211(3次方)= . 1010100010*2^1010(10次方) 尾数: . 1010100010 指数:1010 基数:2浮点数字面量默认都为double类型,所以在定义的float型数据后面加F 或 f;double类型可不写后缀,但在小数计算中一定要写D或 X.X
float的精度没有 long 高,有效位数(尾数)短。
float的范围大于 long指数可以很大。
浮点数是不精确的,不能对浮点数进行精确比较。
3.一种字符类型(char): char:16位,是整数类型,用单引号括起来的1个字符(可以是一个中文字符),使用Unicode码代表字符,0~2^16-1(65535) 。
注意事项:不能为 0个字符。
转义字符:\n换行,\r 回车,\t Tab字符," 双引号,\ 表示一个,两字符char中间用“+”连接,内部先把字符转成 int 类型,再进行加法运算,char本质就是个数!二进制的,显示的时候,经过“处理”显示为字符
4.一种布尔类型(boolean):true真和false假。
5.类型转换:char-->自动转换:byte-->short-->int-->long-->float-->double 强制转换:①会损失精度,产生误差,小数点以后的数字全部舍弃。②容易超过取值范围。
6.记忆:8位:Byte(字节型),:short(短整型)、char(字符型),32位:int(整型)、float(单精度型/浮点型),64位:long(长整型)、double(双精度型),最后一个:boolean(布尔类型
7.整形的字面值类型是int,byte、short、char、在范围内可以直接赋int值。浮点类型的字面值double。类型后缀,long、double、float
数组
Arrays.toString()方法:将数组转换为字符串
Arrays.sort()方法,默认给数组做从小到大排序
数组扩容
int arr[]=new int[1];
int arr={1,2};
Arrays.copyOf(original,newLength)
Orginal:代表要复制的数组
newLength:新长度
- 新长度比原来长度小
- 新长度和原长度一样
- 新长度比原长度长 /**********原数组全复制下来后用0补位
ArrayIndexOutOfBoundsException 数组下标越界异常
面向对象特点
- 符合人们的思考习惯
- 将复杂问题简单化,由过程编程转为面向对象
- 使过程中的执行者成为对象的指挥者
Java语言对现实事物进行描述,通过类的形式来体现
描述方式:事物的属性和行为
只要明确事物的属性和行为并定义在类中
对象就是该类事物实实在在存在的个体
类与对象的关系:事物的描述
对象:该类事物的实例,通过new来创建
注意:java中所有的关键字都是小写的,String是类不是关键字以及基本类型
定义类就是定义类中的成员
成员:成员变量属性,成员变量行为
成员变量和局部变量的区别
1.成员变量定义在类中,整个类都可以访问
局部变量定义在函数,语句,局部代码块中,只在所属区域有效
2.成员变量存在于堆内存的方法中
局部变量存在于栈内存的方法中
3.成员变量随着对象的创建而存在,随着对象的消失而消失
局部变量随着所属区域的执行而存在,随着所属区域的结束而释放
4.成员变量都有默认初始值
局部变量没有初始值
在类中定义成员变量赋值时是显式初始化,对象的属性赋值后被清除,无需显式初始化,java默认给隐式初始化赋值
类类型的变量要指向对象,否则就是null
匿名对象:没有名字的对象,
new 类名(); //匿名对象其实就是对象的简写格式
类名 对象名=new 类名()
对象名.方法();
当对象方法仅进行一次调用时候就可以简化为匿名对象+
toString方法
重写toString方法后输出对象就会输出toString方法重写后的。
传参
1.基本类型传参:
public class Transfer_parameters {
public static void main(String[] args){
int x=3;
show(x);
System.out.print(x);
}
static void show(int x){
x=4;
}
} /*********方法结束后局部变量消失/;
2.引用类型传参
class demo{
int a;
public static void run(demo d){
d.a=4;
}
}
public class Transfer_parameters_2 {
public static void main(String[] args){
demo d=new demo();
d.a=9;
d.run(d);
System.out.print(d.a);
}
} /********传参后经过方法改变属性,会被方法所改变;/
4. 数组传参排序
public class Sort
{
public static void main(String[] args)
{
int[] a={5,6,4,7};
Orr(a);
}
static void Orr(int a[]){
//第一次循环,是确定一个数依次和后面数的比较的数。
for (int i = 0; i < a.length -1 ; i++) {
//这个是和第一个数的比较的数
for (int j = i+1; j < a.length; j++) {
//定义一个临时的变量,用来交换变量
int temp ;
if(a[i]>a[j]){
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
for(int x=0;x<a.length;x++){
System.out.println(a[x]);
}
}
}
封装,是指隐藏对象的属性和实现细节,仅对外提供公共访问方式
私有属性只在类内可访问,外界不可访问
好处:将变化隔离,便于使用,提高重用性,提高安全性
封装原则:将不需要对外提供的内容都隐藏起来,把属性都隐藏,提供公共方法对其访问
package q.Review;
class person{
private int age;
public void setAge(int a){
if(a>0&&a<130){
age=a;
}
}
public int getAge(){
return age;
}
void show(){
System.out.print(age);
}
}
public class Encapsulation {
public static void main(String[] args){
person a=new person();
a.setAge(10);
a.show();
}
}
Private关键字:是一个权限修饰符,用于修饰成员(成员变量和成员函数),被私有化的成员只在本类中有效
常用:将成员变量私有化对外提供get ,set 方法对其进行访问,提高数据访问的安全性。
set方法一般是void,get返回类型和属性类型相同
构造函数
特点:函数名与类名相同,不用定义返回值类型,没有具体的返回值
作用:给对象进行初始化
注意:默认构造函数的特点,多个构造函数是以重载的形式存在的。
在构建创造对象是所调用,可以给对象进行初始化。
一个类中如果没有定义过构造函数,那么该类中会有一个默认的构造函数,如果类中定义了指定的构造函数,那么类中的默认构造函数就没有了。
构造函数和一般函数的区别
构造函数:对象创建时,就会调用与之相对应的构造函数,对对象进行初始化
一般函数:对象创建后需要函数功能时才能使用
构造函数:对象创建时,会调用只调用一次
一般函数:对象创建后,可以调用多次
package q.Review;
class Per{
int age;
Per(){
System.out.println("success");
}
void speak(){
System.out.print("speak");
}
}
public class ConstructorFun {
public static void main(String[] args){
Per P=new Per();
P.speak();
P.speak();
P.speak();
}
}
定义构造函数的时候:在描述事物时,该事物已存在就具备的一些内容,这些内容都定义在构造函数中。
重载
package q.Review;
class Pers{
private int age;
private String name;
Pers(){
}
Pers(String n){
name=n;
}
Pers(String n,int a){
name=n;
age=a;
}
void speak(){
System.out.println(age+name);
}
}
public class Overloaded {
public static void main(String[] args){
Pers P0=new Pers();
P0.speak();
Pers p1=new Pers("旺财");
p1.speak();
Pers p2=new Pers("旺财",10);
p2.speak();
}
}
函数名或者方法名有相同,参数列表或参数类型不相同。
- 重载发生在一个类里
- 重载的方法名相同
- 重载的参数列表不一样
- 重载的方法体不同
参数列表不同的点: - 参数类型
- 参数个数
- 参数类型相同并且参数个数相同,传参顺序不同,参数列表也不同
this关键字
特点:代表其所在函数所属对象的引用,
当在函数内需要用到调用该函数的对象时,就用this
当成员变量和局部变量重名时可以用关键字this来区分
this代表当前对象
this就是所在函数所属对象的引用
简单说,哪个对象调用了this所在的函数,this就代表哪个对象
static关键字
static是一个修饰符,用来修饰成员
static修饰的成员被所有对象所共享
static优先于对象存在,因为static的成员随着类的加载就已经存在了
static修饰的成员多了一种调用方式,就可以直接被类名所调用。格式:类名.静态成员
static修饰的数据是共享数据,对象的存储是特有数据
class personStatic{
String name; //成员变量,实例变量
static String country="CN"; //静态变量,类变量
public void show(){
System.out.println(country+" :"+name);
}
}
public class staticKeyword {
public static void main(String[] args){
personStatic p=new personStatic();
p.name="小强";
p.show();
System.out.println(p.country);
System.out.print(personStatic.country);
}
}
成员变量和静态变量的区别
1.两个变量的生命周期不同
成员变量随着对象的创建而存在,随着对象的被回收而释放
静态变量会随着雷德加载而存在,随着类的消失而消失(一般随着虚拟机的结束类消失)
// 不用静态的原因有一部分是因为生命周期太长
2.调用方式不同
成员变量只能被对象调用
静态变量可以被对象调用,还可以被类名调用
3.别名不同
成员变量也成为实例变量
静态变量称为类变量
4.位置不同
成员变量数据存储在堆内存的对象中,所以也叫对象的特有数据
静态变量数据存储在方法区(共享数据区)的静态区,所以也叫对象的共享数据
静态使用注意事项:
1.静态方法只能访问静态成员(成员变量和成员函数),非静态既可以访问静态又可以访问非静态
2.静态方法中不可以使用this或者super关键字(原因是无对象)
3.主函数是静态的(调用方式如下)
public class staticSecond {
int num=10;
public static void main(String[] args){
new staticSecond().show();
}
public void show(){
System.out.print(num);
}
}
继承
在继承的关系中,子类就是一个父类,也就是说,子类可以被当做父类看待
定义父类格式(一个普通的类定义):
public class 父类名称{
}
定义子类格式
public class 子类名称 extends 父类名称{
}
无法继承:
父类的私有属性子类无法继承
父类的构造函数
在父子类的继承关系中,如果成员变量重名,则创建子类对象时,访问有两种方式
直接通过子类对象访问成员变量:
等号左边是谁,就优先用谁,没有则向上找
间接通过成员方法访问成员变量:
该方法属于谁,就优先用谁,没有则向上找
Demo01ExtendsField
package q.Extends;
public class Demo01ExtendsField {
public static void main(String[] args){
FatherClass fa=new FatherClass();//创建父类对象
System.out.println(fa.numFa);//只能使用父类的东西,没有任何子类内容
System.out.println("=");
Son s=new Son();
System.out.println(s.numFa);//10
System.out.println(s.numSon);//20
System.out.println("=");
//等号左边是谁,就优先用谁
System.out.println(s.num);//优先子类
//System.out.println(s.abc);//到处都没有,编译报错
System.out.println("===========");
//这个方法是子类的,优先用子类的,而没有向上找
s.methodZi();
//这个方法是在父类定义的
s.methodFu();//100
}
}
FatherClass
public class FatherClass {
int numFa=10;
int num=100;
public void methodFu(){
//使用本类当中的不会向下找
System.out.println(num);
}
}
son
package q.Extends;
public class Son extends FatherClass{
int numSon=20;
int num=200;
public void methodZi(){
//因为本类中有,所以用本类的
System.out.println(num);
}
}
@Override是伪代码,表示重写(当然不写也可以),不过写上有如下好处: 1、可以当注释用,方便阅读; 2、编译器可以给你验证@Override下面的方法名是否是你父类中所有的,如果没有则报错。例如,你如果没写@Override,而你下面的方法名又写错了,这时你的编译器是可以编译通过的,因为编译器以为这个方法是你的子类中自己增加的方法。 举例:在重写父类的onCreate时,在方法前面加上@Override 系统可以帮你检查方法的正确性。
重写:
-
重写发生在父子类中
-
重写的方法名称相同
-
重写的参数列表相同
-
重写的方法体不同
-
父类的方法不满足子类的需求
-
重载发生在一个类里
-
重载的方法名相同
-
重载的参数列表不一样
-
重载的方法体不同
多态
1.向上造型:将父类型的引用指向子类型的对象
2.向下造型:将指向子类型对象的父类型引用 再转回子类型
强制类型转换
抽象
抽象方法:就是加上abstract关键字然后去掉大括号,直接分号结束
抽象类:抽象方法所在的类必须是抽象类才行,在class之前写上abstract即可
抽象类声明:
public abstract class 类名{
}
没有方法体
一个类继承了抽象类,必须实现父类的抽象方法,不能直接创建抽象类对象,必须用一个子类来继承抽象父类,子类必须覆盖重写父类中的所有抽象方法
覆盖重写(实现):子类去掉抽象方法的abstract关键字,然后补全方法体大括号
创建子类对象时使用
一个抽象类不一定含有抽象方法,只要保证抽象方法所在的类是抽象类即可,这样没有抽象方法的抽象类,也不能直接创建对象,在一些特殊场景下有用途
注意:
- 抽象类不能创建对象,如果创建就会报错只能创建其非抽象子类的对象
理解:假设创建了抽象类的对象,调用抽象的方法,而抽象方法没有具体的方法体,没有意义 - 抽象类中可以有构造方法,是供子类创建对象时初始化父类成员使用的
理解:子类的构造方法中,有默认的super(),需要访问父类的构造方法 - 抽象类中,不一定包含抽象方法,但是有抽象方法的类必定是抽象类
理解:未包含抽象方法的抽象类,目的就是不让调用者创建该类对象,通常用于某些特殊的类结构设计 - 抽象类的子类必须重写父类的所有抽象方法,否则无法编译并报错,除非该子类也是抽象类。
理解:假设不重写所有抽象方法,则类中可能包含抽象方法,那么创建对象后,调用抽象的方法,没有意义
接口:与类同级
类:属性 行为 静态常量
继承只能单继承
实现可以多实现
继承在前实现在后
在最需要奋斗的年华里,不要选择安逸,许多事情,是做了才有希望,而不是看到希望才去做
本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利。