Java笔记记录

1.java语言是编译(字节码文件)+解释执行(虚拟机翻译成对应平台的机器码)两种类型的结合
2.Java语言两个核心机制 1.Java虚拟机:可运行Java字节码文件的虚拟计算机 2.垃圾回收器
3.JDK包含:
java运行时环境:JRE
java编译器:javac.exe
java运行时解释器:java.exe
java文档化工具:javadoc.exe

jdk,jre,jvm的关系:
jdk java开发工具,开发和运行java程序
jre java运行环境,只运行java程序
jvm java虚拟机,编译，翻译，运行，分配内存, 因为在不同平台上，要安装不同平台的jdk,而jdk包含了jvm,jvm在运行java代码的时候，
会翻译成对应平台能识别的底层代码去运行 三者包含关系为:jdk>jre>jvm

4.番外篇
帕斯卡命名法：每个单词的首字母大写，如
MyName, MyGirlFriendName 一般用于类名上
驼峰命名法：第一个单词首字母小写，其他单词首字母大写，如
myName, myGirlFriendName 一般用于变量和方法上
保留字:煤油定义用途,但保留备用 如:goto

5.switch括号内允许类型：1. int (byte short char 这三种可转换成int) 2. enum 3. String (jdk1.7之后的版本)
String 不是关键字，时Java基础库中的一个常用类 byte short char三者在计算时会自动转换成int类型

6.正则表达式
String reg = “\d{4}”; //四位会员号
String birthdayReg = “(0[1-9]|1[0-2])/(0[1-9]|[1-2][0-9]|3[0-1])”; //生日格式(月/日):01/09
matches():字符串匹配正则表达式方法

7.变量
1.局部变量没有初始值，必须手动赋予初始值才能使用,全局变量有初始值，原生类的初始值为0，其他为null
2.成员变量作用于整个类,局部变量作用于方法和语句中
3.成员变量被创建时出现在堆内存中,随着对象的出现消亡而出现消亡,局部变量在被运算时出现在栈内存中,运算结束即被释放
4.引用数据类型:类,接口,数组

8.线性表
分两种： 顺序(线性)存储和链式(链表)存储
顺序存储的优点是查询效率高，缺点是在非最后的位置插入和删除效率低

9.排序
冒泡排序: https://blog.csdn.net/u012864854/article/details/79404463
选择排序: https://blog.csdn.net/cjf_iceking/article/details/7914554
二分查找: https://www.cnblogs.com/luoxn28/p/5767571.html

11.栈:中主要存放一些基本类 型的变量和对象句柄(引用类型的地址),特点：先进后出，一般空间比较小
堆:存储引用类型数据，特点：空间比较大，存储速度相对较慢
基本数据类型在被创建时，在栈上给其划分一块内存，将数值直接存储在栈上。
引用数据类型在被创建时，首先要在栈上给其引用（句柄）分配一块内存，而对象的具体信息都存储在堆内存上，然后由栈上面的引用指向堆中对象的地址。

静态区： 保存自动全局变量和 static 变量（包括 static 全局和局部变量）。静态区的内容在总个程序的生命周期内都存在，由编译器在编译的时候分配。
堆区：  一般由程序员分配释放，由 malloc 系列函数或 new 操作符分配的内存，其生命周期由 free 或 delete 决定。在没有释放之前一直存在，直到程序结束，由OS释放。其特点        是使用灵活，空间比较大，但容易出错
栈区： 由编译器自动分配释放，保存局部变量，栈上的内容只在函数的范围内存在，当函数运行结束，这些内容也会自动被销毁，其特点是效率高，但空间大小有限
文字常量区： 常量字符串就是放在这里的。   程序结束后由系统释放。

12.instanceof是Java的一个二元操作符，它的作用是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据。 Teahcer和Student之间没有继承关系不能做强制类型转换。
a instanceof Dog //a引用是否为狗类的实例

13.什么是C/S程序，B/S程序
Client/Server 客户端/服务器
Browser/Server 浏览器/服务器

14.静态方法,非静态方法
1.同类中静态方法能直接调用静态方法和成员,调用非静态方法和非静态成员要创建对象(即实例化类),非静态方法能直接调用静态和非静态的方法与成员
2.访问其他类的静态成员变量和静态方法直接用类名点出来
3.静态方法(类方法)是在类中使用staitc修饰的方法，在类定义的时候已经被装载和分配。
4.非静态方法(实例方法)是不加static关键字的方法，在类定义时没有占用内存，只有在类被实例化成对象时，对象调用该方法才被分配内存。
5.super和this关键字只能用于构造方法和静态方法,因为在非静态方法调用的时候,指代的对象可能还没有创建

15.static关键字作用

1. static修饰的属性为类属性,修饰的方法为类方法,不依赖于实例,只依赖于类,最早加载,静态成员可使用类名直接访问，也可用对象名访问
2. static修饰的方法属于类方法,不依赖于对象直接通过类名.方法名()调用
3. static修饰属性一般要和final一起使用变为静态常量,静态常量就无需实例化,方便调用,因为static修饰的属性会有共享安全问题,多个实例修改是同一份空间,
4. 静态方法不能直接调用实例属性和实例方法,因为没有this,要调用的话,需要先实例化对象.
   5.static修饰的属性和方法不易于GC回收,太多容易造成内存溢出
   6.static不可以在方法内部修饰属性
   构造代码块:声明在类体中,用于初始化工作,每创建一次对象执行一次(优先于类构造方法)
   {
   System.out.println(“构造代码块执行”);
   }

静态代码块:用static修饰的动态代码块,类加载时自动执行,且只执行一次,静态代码块不能存在于任何方法体内。
static {
System.out.println(“这是静态代码块”);
}

public static String s = getString();
private static String getString() {
System.out.println(“给静态变量赋值的静态方法执行：loading line”);
return “ss”;
}

普通代码块:声明在方法中的代码块,普通代码块和一般的语句执行顺序由他们在代码中出现的次序决定–“先出现先执行”
链接: https://blog.csdn.net/qq_27093465/article/details/75339803

16.final关键字作用

1. final修饰属性代表最终的属性,即常量,不可修改, 当修饰的属性为引用类型时,代表引用不可变,但是引用里面的属性可变
2. final修饰方法代表最终的方法,不可以重写,能被继承
3. final修饰的类代表最终的类,不可以继承

17.this关键字:对当前对象的引用
1. this关键字只能使用在实例方法和构造方法中
2. this可以访问实例属性,实例方法,和构造方法
3. this访问构造方法时,必须在构造方法的第一行
this.属性 //访问本类的成员属性,区分成员变量名和形参变量名一样的情况
this.方法 //访问本类的成员方法
this() //访问本类中其他构造方法,只能写在第一句,只能出现一次,例:某构造方法有1,2,3,4个参数,可以用this(1,2);this.3=3;this.4=4;进行初始化

super关键字

1. super代表调用父类实例
2. 如果子类没有父类的属性,那么super和this调用的是同一份空间
3. 如果子类有的话,super和this获取到的数据不一样,super设置父对象的空间,this设置本身的空间
4. 子类如果重写了父类的方法,那么this.method()会调用子类的重写的方法,但是属性不会,因为属性不存在重写.
   super.属性 //访问父类的属性,子类定义了与父类同名的属性时,只能通过super访问父类属性
   super.方法 //调用父类的方法,子类调用父类没有被重写的方法
   super()//调用父类构造方法,super()必须是子类构造方法第一条语句,子类构造方法第一条语句默认调用父类无参构造方法,也可手动调用父类带参构造方法

18.访问修饰符作用域
public:所有用户都可调用
protected:同包和不同包子孙类
fridenly:同包
private:本类才能使用

19.字符编码
ASCII码:127个字符
ANSI码:扩展到65536个字符
Unicode编码:扩展到每个字符
UTF-8编码:解决Unicode编码浪费内存问题

20.System.err和System.out的使用区别: https://blog.csdn.net/captainCZY/article/details/79496959

21.java继承
1.java是单继承,一个类只能继承自一个父类
2.继承可以使用 extends 和 implements 这两个关键字来实现继承，所有的类都是继承于 java.lang.Object，当一个类没有写这两个关键字，则默认继承object祖先类
3.子类继承父类所有属性和方法,但是只能访问有权限的属性和方法
4.使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）
5.子类用this.XXX()方法的时候,若子类没有该方法,即使用this也是调用父类的方法,子类有该方法时才用自己的方法,子类父类都有该方法时,子类调用的就用子类的方法

22.抽象类与抽象方法(abstract)

1. 当一个类作为父类使用,本身不需要被实例化的时候,可以设置为抽象类,抽象类不能被实例化
2. 抽象方法必须包含在抽象类中,本身没有方法体,因为无法调用,所以没有实例
3. 抽象方法的作用是为了设置标准,限制子类必须按这个方法签名去重写方法
4. 子类必须重写父类的抽象方法,除非子类又是一个抽象类
5. 抽象方法可以实现多态:编译阶段父类有抽象方法才能使用多态调用子类重写的父类的抽象方法
   6.final要求方法不能被重写,abstract要求方法必须被重写,这2个关键字不能同时使用

23.java接口
1.接口不具有构造方法,接口不能实例化
2.接口中只能包含公共的静态常量(static final),而抽象类中的成员变量可以被不同的修饰符来修饰
3.如果子类是非抽象类，则必须实现接口中的所有方法；
4.如果子类是抽象类，则可以不实现接口中的所有方法，因为抽象类中允许有抽象方法的存在！
5.接口中的静态方法不可以被实现,JDAK1.8 后:可以包含静态方法和默认方法
是属于这个类的，不是属于对象的。没有继承不继承的说法。
6.接口也有抽象方法,且只有抽象方法,没有方法体,只能用public声明
7.抽象类是对象的抽象，然而接口是一种行为规范。
8.接口的访问修饰符只能是public或者默认修饰符

24.方法的重载：
1.必须是在同一个类中,方法名相同
2.方法参数的个数、顺序或类型不同,与方法的修饰符或返回值没有关系

25. 重写
26. 发生在子父基础关系中,子类重写父类方法
27. 方法名和参数列表必须相同
28. 访问权限不能比父类更严格,也就是要比父类更大(大是什么意思?)
29. 返回值类型必须相同或者是父类方法返回值的子类
30. static方法无法重写
31. 声明的异常不能比父类更大

26.Java构造方法:创建对象时，初始化该对象
1.构造方法的方法名必须与类名一样。
2.构造方法没有返回类型,在方法名前面不能声明方法类型,也不能定义为void。
3.构造方法不能作用是完成对象的初始化工作，他能够把定义对象时的参数传递给对象的域。
4.构造方法不能由编程人员调用，而要系统调用。
5.构造方法可以重载，以参数的个数，类型，或排序顺序区分,不可以重写
6.可由构造方法或get()方法给类的成员变量初始化,new对象必须要执行构造方法
7. 每一个类在没有手动设置构造方法的时候都有一个默认的public构造方法
8.一个类中有有参构造方法,而删除了无参构造方法,这时创建对象的时候必须用有参构造方法初始化对象,否则报错,因为默认的无参构造方法被覆盖了
9.初始化对象时无参,就走默认构造,有参就走有参构造
10.子类不继承父类的构造方法,它只是调用父类的构造方法。
如果父类的构造方法带有参数，则子类必须显式地通过 super 关键字调用父类的构造方法并配以适当的参数列表。
如果父类构造方法没有参数，则子类会自动调用父类的无参构造方法。
public class Animal {
String name;
int id;
public Animal(String myName, int myid) {
name = myName;
id = myid;
}
}
public class Mouse extends Animal {
public Mouse(String myName, int myid) {
super(myName, myid);
}
}

27.Java多态:同一个引用类型,使用不同的实例,执行不同的操作
多态的三种实现:1.父类的引用指向自类的对象 2.重载和重写 3.可变参数
1.向上转型:子类对象赋值给父类变量,自动转换
此时通过父类引用变量调用的方法是子类重写了的父类的方法(子类重写父类,默认走子类的方法)
此时通过父类引用变量无法调用子类自己独有的属性和方法,在不向下转型的情况下可给需要的
//使用多态前的代码
public void feed(Dog d) {
System.out.println(name + “要给狗狗为食”);
d.eat();
d.print();
}
public void feed(Cat c) {
System.out.println(name + “要给猫猫为食”);
c.eat();
c.print();
}
//1.使用父类作为方法形参实现多态
public void feed(Pet p) {
String n = p.getName();
System.out.println(name + “要给”+n+“为食”);
p.eat();
p.print();
}
//2.使用父类作为方法返回值实现多态
public Pet adopt(int type) {
*if (type == 1) {
Pet d = new Dog(); //父类的引用指向子类的对象(宠物父类Pet的引用d指向子类狗对象)
d.setHealth(80);
return d;
} else if (type== 2) {
Pet c = new Cat();
c.setHealth(80);
return c;
} else {
return null;
}
}

2.向下转型:将父类的变量赋值给子类变量,强制转换
向上转型解决代码重复，一旦向上转型了，当需要用到子类的方法时，就需要向下转型，也就是为什么要向下转型也解决了。
向上转型只能引用父类对象的属性，要引用子类对象属性，则要写getter函数。
public void play(Pet pet) {
if (pet instanceof Dog) {
Dog d = (Dog) pet; //子类型 引用变量名 = (子类型)父类型引用变量
d.catchBall();
} else if (pet instanceof cat) {
Cat c = (Cat) pet;
c.hideAndSeek(); //如果没有转换为真实子类类型,则出现类转换异常ClassCastException
}
}