Java复习笔记

一、 cmd编译，cd进入文件路径，javac 项目名.java，
执行：java 项目名
二、 编码标准 定义包名：com/cn等等.企业名
定义类名：开头大写字母+英文名_大写字母_方式
三.
编译版本与执行版本不一致

基本数据类型
1.四种整数类型(byte、short、int、long):byte：8 位，用于表示最小数据单位，如文件中数据，-128~127
short：16 位，很少用，-32768 ~ 32767
int：32 位、最常用，-2^31-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.102^{10（2次方)=1010100.010*2}11(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：新长度

1. 新长度比原来长度小
2. 新长度和原长度一样
3. 新长度比原长度长 /**********原数组全复制下来后用0补位

ArrayIndexOutOfBoundsException 数组下标越界异常

面向对象特点

1. 符合人们的思考习惯
2. 将复杂问题简单化，由过程编程转为面向对象
3. 使过程中的执行者成为对象的指挥者

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();
}
}

函数名或者方法名有相同，参数列表或参数类型不相同。

1. 重载发生在一个类里
2. 重载的方法名相同
3. 重载的参数列表不一样
4. 重载的方法体不同
   参数列表不同的点：
5. 参数类型
6. 参数个数
7. 参数类型相同并且参数个数相同，传参顺序不同，参数列表也不同

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. 重写的方法名称相同

3. 重写的参数列表相同

4. 重写的方法体不同

5. 父类的方法不满足子类的需求

6. 重载发生在一个类里

7. 重载的方法名相同

8. 重载的参数列表不一样

9. 重载的方法体不同

多态
1.向上造型：将父类型的引用指向子类型的对象
2.向下造型：将指向子类型对象的父类型引用 再转回子类型
强制类型转换

抽象
抽象方法：就是加上abstract关键字然后去掉大括号，直接分号结束
抽象类：抽象方法所在的类必须是抽象类才行，在class之前写上abstract即可
抽象类声明：
public abstract class 类名{

}
没有方法体
一个类继承了抽象类，必须实现父类的抽象方法，不能直接创建抽象类对象，必须用一个子类来继承抽象父类，子类必须覆盖重写父类中的所有抽象方法
覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补全方法体大括号
创建子类对象时使用
一个抽象类不一定含有抽象方法，只要保证抽象方法所在的类是抽象类即可，这样没有抽象方法的抽象类，也不能直接创建对象，在一些特殊场景下有用途
注意：

1. 抽象类不能创建对象，如果创建就会报错只能创建其非抽象子类的对象
   理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义
2. 抽象类中可以有构造方法，是供子类创建对象时初始化父类成员使用的
   理解：子类的构造方法中，有默认的super（），需要访问父类的构造方法
3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类
   理解：未包含抽象方法的抽象类，目的就是不让调用者创建该类对象，通常用于某些特殊的类结构设计
4. 抽象类的子类必须重写父类的所有抽象方法，否则无法编译并报错，除非该子类也是抽象类。
   理解：假设不重写所有抽象方法，则类中可能包含抽象方法，那么创建对象后，调用抽象的方法，没有意义

接口：与类同级
类：属性 行为 静态常量

继承只能单继承
实现可以多实现

继承在前实现在后