JavaSE （二）
this关键字
当一个对象创建后，Java虚拟机（JVM）就会给这个对象分配一个引用自身的指针，这个指针的名字就是 this。
用法：对当前对象的默认引用 调用自己的的构造方法。
用在构造方法内部，区分同名的成员变量和局部变量；
this（name.age）;调用构造方法，减少代码冗余；
可用于调用成员属性和成员方法（调用方法时可以省略）。
public class TestClass
{
int x,y;
void testShow(int x,int y){
this.x=x; //this.x 就是我们上 int x,y;中的x 。=x是我们传来的x
this.y=y;
}
}
继承中 this 和 super：
假如父类中有一个方法是 add（）
子类没有重写父类的方法，super.add() 和this.add() 都是调的父类的方法， 没什么区别，如果重写了this.add()就默认调本类的方法，super就默认调父类的方法。
再在子类中，都不写的话，如果有重写父类的add()方法的话就默认调本类的add()方法， 如果本类没有重写就调父类的方法。
static关键字：
用法： 修饰成员变量，表示静态变量（类变量），可以被更改，所有实例对象共享；
修饰方法，表示静态方法（类方法）；
可用类或实例对象调用，一般只用类调用。
static定义的属性一旦被某一个实例化对象更改，则其余对象调用的为更改后的值；
static修饰的变量一旦写入便生成空间，默认值为0，其他对象只有实例化后才被分配空间。
类的加载和对象实例化：
构造方法：创建类的对象时定义的初始化状态，无返回值，不能用void修饰，命名必须和类名相同。
不能被直接调用，只能在new运算符在创建对象时被自动调用，在定义一个类时，java编译器会自动生成一个无参构造函数。
普通方法：命名可以和构造方法相同，但必须带返回值，在程序执行到它时被调用。
public class Demo4 {
public static void main(String[]args){
System.out.println(A.instance.num2);
System.out.println(new A(1).num2);
}
}
class A{
static A instance=new A(1);
static int num1=5;
int num2;
A(int num3){
num2=num1-num3;
}
}
//用第一种方法调用时，A与num2均先开辟空间，在执行newA(1)时，5还未赋值给num1；
//执行后num1赋值为5；
//num1默认值为0.0-1=-1；
//用第二种方法调用时，先实例化了一个A对象，此时，num1=5，5-1=4.
静态块：
public class Test {
public Test() {// 构造方法
System.out.println("我是构造方法，创建对象的时候我会执行，我执行完，对象就造出来了");
}
static {
System.out.println("我是静态块，类加载的时候我就执行了，而且只执行这一次");
}
}
然后这样：
new Test();
new Test();
当创建Test类的一个对象的时候，比如new Test() ,是这样，首先是类加载，然后才能new对象，静态块在类加载的时候就执行了，这就说明静态块在new对象之前就会执行，而且一个类在第一次被使用的时候会被加载，然后在整个应用程序的生命周期当中不会再次被加载了，就加载这一次，所以这就说明，静态块就执行一次，不会执行第二遍！
对象的实例化：
创建对象：Student stu1 = new Student();
实例对象：Student stu2 = new Student("张三",21,"男");
可以看出实例对象调用了Student类的构造方法，为创建的对象赋了值，
而创建对象只是创建了一个对象。
程序阅读训练：
new A类.B方法（）； 实例化一个对象并调用B方法
实例方法可调用静态方法或静态变量；
静态方法不可调用实例方法；
静态方法中不能有非静态的方法或变量。
继承：
在Java 术语学中，被继承的类叫超类（superclass ），继承超类的类叫子类（subclass ）。子类是超类的一个专门用途的版本，它继承了超类定义的所有实例变量和方法，并且为它自己增添了独特的元素。
语法：单根继承（接口可实现多继承），一个子类只能继承一个类，一个类可以有多个子类。
super：在子类中通过super调用父类的属性和行为；
super表示父类对象。
class Fu{
}
class Zi extends Fu{
}
子类不能继承父类的显式定义的构造方法，若想要继承父类的构造方法，需要通过覆盖该构造方法，并在方法中通过super调用父类的该构造方法的方式来继承。
继承的三种情况说明：
1、父类中没有显式定义任何构造方法，此时父类中实际有一个默认的无参数构造方法。这时，在子类中显式定义任何构造方法时，可以不用使用super调用父类的默认方法。
2、父类中显式定义了默认的无参数构造方法，那么子类可以定义任意的构造方法，而不必使用super调用父类的构造方法
3、父类中显示定义了构造方法，却没有显示定义默认的无参数构造方法，那么子类定义任何构造方法中都需要通过super调用父类的构造方法
import和package：
包名写法规范：域名倒置 即 公司名.项目名.模块名.子模块名...
语法---打包命令
javac-d.Table.java
package oop3
package oop2
a.通过全类名引用
oop2.类名+实例化对象=new oop2.类名（）；
b.直接导包
import+包名.类名；
import+包名.*;表示导入与此包中相关的所有类。
Java.lang 包：
是Java语言的核心类库，包括了运行Java程序必不可少的系统类，如基本数据类型、基本数学函数、字符串处理、线程、异常处理类等。每个Java程序运行时，系统都会自动地引入java.lang包，所以这个包的加载是缺省的。
访问修饰符：
为了程序的安全，需要访问修饰符
a. public：同一类，同一包中的子类，不同包的子类，其他包的类均可访问。
b.protected：同一类，同一包的子类，不同包中的子类
c.default：默认（可省）同一类或同一包中的类可访问。
方法的重写：
方法的重写也称为方法的覆盖（override），对于某一个子类而言，他的方法与其父类的方法内容不尽相同。
条件：方法名称相同，参数特征完全相同，返回值类型相同；
访问修饰符范围不能缩小；
子类重写父类方法，没有继承，则不存在重写；
子类方法不能抛出比父类更大的异常。
public class TestStaticMethodExtends {
public static void main(String[] args) {
A a = new B(); //父类类型指向子类对象。
a.p(); //调用子类p方法。
}
}
class A {
public static void p() {
System.out.println("基类");
}
}
class B extends A {
public static void p() {
System.out.println("子类");
}
}
程序绑定：
概念：绑定指的是一个方法的调用与方法所在的类(方法主体)关联起来。对java来说，绑定分为静态绑定和动态绑定；或者叫做前期绑定和后期绑定
动态绑定：在运行时根据具体对象的类型进行绑定。
| 栈区 | 方法栈 | 堆区 |
动态绑定的过程：
虚拟机提取对象的实际类型的方法表；
虚拟机搜索方法签名；
调用方法。
父类类型指向子类对象:
Animal a=new Animal();
Tiger t=new Tiger();
Animal a2=new Tiger();
Tiger t=new Animal(); //错误写法，不能使子类对象指向父类实例
引用对象 实例化对象
| a | ------------------> | new Animal（） |
| t | ------------------> | new Tiger（） |
| a2 | ------------------> | new Tiger（） |
实例代码（来源网络）：
public class Father {
public void method() {
System.out.println("父类方法，对象类型：" + this.getClass());
}
}
public class Son extends Father {
public static void main(String[] args) {
Father sample = new Son();//向上转型
sample.method();
}
}
声明的是父类的引用，但是执行的过程中调用的是子类的对象，程序首先寻找子类对象的method方法，但是没有找到，于是向上转型去父类寻找静态绑定：
概念及用法：
在程序执行前方法已经被绑定，此时由编译器或其它连接程序实现。例如：C。
针对java简单的可以理解为程序编译期的绑定；这里特别说明一点，java当中的方法只有final，static，private和构造方法是前期绑定在处理java类中的成员变量时，并不是采用运行时绑定，而是一般意义上的静态绑定。所以在向上转型的情况下，对象的方法可以找到子类，而对象的属性还是父类的属性。
Java当中只有final（无子类），static，private和构造方法是静态绑定。
示例代码（来源网络）
public class Father {
protected String name="父亲属性";
public void method() {
System.out.println("父类方法，对象类型：" + this.getClass());
}
}
public class Son extends Father {
protected String name="儿子属性";
public void method() {
System.out.println("子类方法，对象类型：" + this.getClass());
}
public static void main(String[] args) {
Father sample = new Son();//向上转型
System.out.println("调用的成员："+sample.name);
}
}
结论，调用的成员为父亲的属性。
toString和instance of：
一切对象皆Object类。
public class A extends Object{}
Object中的toString（）方法：
Object中的toString（）方法返回一个字符串，该字符串由类名（对象为该类的一个实例）、“@标识符”和此对象的哈希码的十六进制表示组成。
Object类中的toString()方法是打印类命和内存地址的。
比如String类就重写了Object的toString()方法.
如果一个object类里的成员有
String str;
float a;
int b;
String tostr;
tostr = new Object().str;这样才是得到Object类的str的值
但是Object是没有这个属性的.当你要得到一个类中的一个非static类型的属性的时候,你要得到它的值可以用
new 类名().属性名 来得到。
用System.out.println()输出一个对象的时候，java默认调用对象的toString()方法
一般要覆盖这个方法，这样根据覆盖逻辑就可以输出自己的对象
比如定义一个类User,有id，name属性，你直接输出一个user对象的话
System.out.println(user)，得到的只是
全限定名@地址首地址
如果在User类里面覆盖这个toString方法的话就能输出你要的
比如
public String toString(){
return "user name is:"+this.name+";"+"user id is:"+this.id;
}
这样你输出一个user对象就是
User user = new User(1,"zhangshan");
System.out.println(user);
得到：user name is :zhangshan;user id is: 1;
instanceof 关键字：
java 中的instanceof 运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例。
A instanceof B 表示A是B的一个实例对象。
用法：
result = object instanceof class
参数：
Result：布尔类型。
Object：必选项。任意对象表达式。
Class：必选项。任意已定义的对象类。
说明：
如果 object 是 class 的一个实例，则 instanceof 运算符返回 true。如果 object 不是指定类的一个实例，或者 object 是 null，则返回 false。
final关键字：
用法:
当某个类不想被继承时
当某个方法不想被重写时
当某个变量值不想被更改时给final修饰的变量赋值：定义时赋值；初始化块；构造方法。
final String STR=“hello”；
public final void hello（）{
}
static final String STR =“hello”； 静态字符串变量，避免每个实例对象都有一份相同的STR值造成的空间浪费。
类变量被final修饰，为宏变量，程序中用到的“Hello”值全部用STR替换。
命名规范与注释：
类和接口：首字母大写（第一个可以小写）
变量和方法：首字母小写，后面每个单词首字母大写，以字母、下划线或$开头。
包：全小写，域名倒置。
常量：全大写，多个单词之间用下划线“—”相连。
final int AGE；
对象与内存控制：
类的加载顺序：
a.父类静态代码块；
b.子类静态代码块；
c.父类非静态代码块；
d.父类构造函数；
e.子类非静态代码块；
f.子类构造函数； 某一个类初次被加载时，静态块会先执行。
例：
public class ExA {
static {
System.out.println("父类静态代码块。");
}
public ExA() {
System.out.println("父类构造函数。");
}
{
System.out.println("父类非静态代码块。");
}
public static void main(String[] args) {
new ExB();
}
}
class ExB extends ExA {
static {
System.out.println("子类静态代码块。");
}
{
System.out.println("子类非静态代码块。");
}
public ExB() {
System.out.println("子类构造函数。");
}
}
执行结果：父类静态代码块。子类静态代码块。父类非静态代码块。父类构造函数。子类非静态代码块。子类构造函数。
访问子类对象的实例变量：
private int i=22； 先给i分配空间，后赋值为22.
调用被子类重写的方法：
在子类中，用super调用父类的属性和方法。
调用父类无参构造函数：super（）
调用父类有参构造函数：super（父类构造方法的参数）
super 为其父类
super.toString() 为调用其父类的toString方法;
static class Parent {
//父类方法
void who() {
System.out.println("I'm parent");
}
}
static class Child extends Parent {
//子类重写方法
@Override
void who() {
System.out.println("I'm child");
}
//通过supper调用父类方法
void parentWho(){
super.who();
}
}
public static void main(String[] args) {
Child child = new Child();
Parent parent = new Parent();
parent.who(); 结果： I'm parent
child.who(); I'm child
child.parentWho(); I'm parent
}
抽象类：
若一个方法无方法主体，在public后有abstract修饰，则该方法是抽象方法，有抽象方法的类称为抽象类。
抽象类不能直接用new实例化。但可以实例化实现了的子类,用父类引用指向子类实例
子类必须继承父类的所有方法，否则子类也是抽象的。
某个类为抽象类，但其中可以无抽象方法。
多态：
对象的向上转型和向下转型：
Tiger t=new Tiger(); 实例化一个Tiger类型t
Animal a=t ； 子类类型实例赋给父类类型对象 即向上转型
子类可以重写父类中的方法，向上转型时，由于子类已经扩充了父类的方法，父类调用的父类的方法已被子类重写，这样 间接的也扩充了父类的功能。
Animal a= new Tiger();父类类型（引用）指向子类对象
Tiger t=（Tiger） a； 子类对象 t 强转Tiger类赋给子类变量 即向下转型，使类型更明确
子类自己的方法无法用继从父类承来的类的实例对象调用，需实例一个子类自己的对象t来调用。
t.eat(); 调用子类特有的方法
向下转型可以调用父类没有定义，但子类实现的方法
比如父类有a()方法，子类重写了a()方法，而且额外添加了一个b()方法，父类中没有b方法
那么要调用子类的b方法，必须将父类变量向下转型为子类才可以调用b方法
|
A a=new B();
B b1=(B)a; a.fun1(); a.fun2(); b1.fun3(); 子类调用从父类继承的方法，利用多态可以直接调用。而fun3是子类自己的方法，使用父类定义的对象是没有办法调用的，所以必须 B b1=(B)a;转换定义类型来进行调用。 |
多态概念：父类的某一种类型在不同子类中表现出不同的形态。
Animal animal=new Monkey（）；
animal.sleep();
Animal animal=new Tiger（）；
animal.sleep();
多态的体现:
父类的引用指向了自己的子类对象
父类的引用也可以接收自己的对象
多态的前提 :
必须是类与类之间只有关系，要么继承或实现
通常还有一个前提，存在覆盖
多态的好处:
多态的出现提高了程序的扩展性
多态的弊端 :
只能使用父类的引用访问父类的成员
接口：
使用规则：关键字+接口名称
接口中的所有变量属性为常量。public static final ，可省
接口中定义的全部方法为抽象方法。public abstract，可省
interface transfer Data(object data); void charge();//电流传输 String STR="hello"; //实现USB功能
接口是最高的抽象，，其包含的所有方法都是抽象方法。
在java中，单根继承，但可多实现。
a，接口继承接口
public interface InterfaceA extends InterfaceB { } 接口继承接口可以不实现父接口中的方法，可以声明自己的新方法；
b, 类继承（实现）接口
public class MiChong implments Usb{ } java类可以一次继承多个接口，用implements 接口1，接口2； 类实现接口时，一定要实现接口中声明的方法，如果接口中没有定义抽象方法则不需要，但是要注意，类实现了一个接口A,如
果B是A的父接口，且B中有抽象方法，则该类必须实现A和B中的所有抽象方法；
抽象方法只能定义在抽象类中，抽象类实现接口，可以不实现接口中的抽象方法。
c，继承加实现
public class KingSD extends A implement Usb，Istore{ }
集合概述：
父接口 Collection
子接口： List 列表 Set
ArrayList：
List接口中的一个实现类。
java.util→Collection→List→ArrayList→add（E,O）
接口 实现类 一个方法
| ------------------------------ |
| ------------------------------- |
| ------------------------------- |
| ------------------------------- |
| ------------------------------- |
实质为数组形式 ，便于查找元素。
LinkedList：
List接口中另一个实现类 List→LinkedList
实质为链表，链表结构的集合类，便于修改增删频繁的情况
泛型初步：
用途：
List personList=new ArrayList(); personList.add(person); add中参数为Object类型，可以add任何一个对象 personList.add(tiger);系统会默认为集合中全为person类 List<Person> personList=new ArrayList<erson>()//泛型，此时返回值是Person类型 而不是Object类型 personList.add(person1); personList.add(tiger);//编译报错 泛型将运行时风险转变成为编译期异常。
泛型语法定义：
public class Person<T>{ //Person类中全为T证件 private String pname; private T card;//证件 }
Set接口：
HashSet为Set的一个实现类。
Set不是线性结构，是以map方式存储。Set中元素按其哈希码存储，每个元素有其固定位置，不可有重复元素。
Set中无get[i]方法。
package set; import java.util.HashSet; import java.util.Set; public class Demo01 { public static void main(String[]args){ Set<String> set=new HashSet<String>();//创建一个参数为字符串的容器 set.add("ton"); set.add("lina");// System.out.println(set.size()); /*下来进行其元素的迭代*/ /*for(int i=0;i<set.size();i++){ set.get(i);在Set中无get这个方法 }*/ //第一种迭代，增强for循环 for(String str:set){ System.out.println(str); } //第二种迭代，转换成数组形式 Object[]objArr=set.toArray(); for(int i=0;i<objArr.length;i++){ System.out.println(objArr[i]); } }//第三种迭代：迭代器Iterator }
hashcode和equals：
equal方法用于判断对象内容是否相同；hashcode判断对象放置的位置是否相同。
Iterator迭代器：
接口：Iterator<E>
主要方法：hasNext（） 判断指向的下一个位置是否还有元素
next（） 返回迭代的下一个元素
remove（） 从迭代器指向的集合中移除元素
iterator（） Iterator中方法的总称
package set; import java.util.HashSet; import java.util.Iterator; import java.util.Set; public class Demo02 { public static void main(String[]args){ String p1="猫"; String p2="狗"; String p3="兔子"; Set <String>set = new HashSet<String>(); set.add(p1); set.add(p2); set.add(p3); System.out.println("----------------"); //Iterator Iterator<String> itor = set.iterator(); while(itor.hasNext()){ String str = itor.next(); System.out.println(str); }
TreeSet：
当中的元素有序。
Comparable接口：
TreeSet具有排序能力。
如果其元素类型是String，则根据字母先后顺序排序。
如果是Integer，则按数字大小来排。
如果是用户自定义类型如Person，则须告诉集合你的排序规则。
Comparable 表示可排序，要表明Person是可排序的。
缺点：排序规则单一。
public class Person inplements Comparable<Person>{ //compareTO() }
//compareTO（）方法
public int CompareTO(Person o){
if(this.age>o.age){
return 1;
}else if(this.age<o.age){
return -1;
}
return 0;
} //该规则按年龄升序排列。
TreeSet 具有排序功能，但若元素为自定义类，则需先实现接口Comparable并调用其compere To方法说明排序规则。
Comparator接口：
特点：有多种排序规则。
public class AgeDesc inplements Comparator<Person>{
public int Compare(Person o1,Person o2){
if(o1.age>o2.age){
return -1;
}else if(o1.age<o2.age){
return 1;
}
return 0;
} //此方法为按年龄降序排序 AgeDesc为年龄降序去实现Comparator接口。
}
使用时需要进行实例化
Comparator<Person> ageDesc=new AgeDesc();
Set<Person>persons = new TreeSet<Person>(ageDesc)；
若要进行身高升序或其他排序方式，则重新定义一个身高升序的类去实现接口Comparator，用主函数（需实例化这个类）进行调用即可。
HashMap：
List：
| ArrayList |
| LinkedList |
Collection：
| List |
| Set |
Set:
| HashSet |
| TreeSet |
Map接口的一个实现类。Map（K，V ）
Map接口的一些方法：
返回map中的值
TreeMap：
容器中元素有序排列。可以对key进行有序排列。
异常语法：
try-catch
try-catch-......catch
try-catch......final 无论是否发生异常 final中的内容都会执行
try-final
异常是程序执行过程中一种不正常的情况，通过try-catch语法对其处理，使程序继续向下运行。
异常语法中的一个类及其两个子类：Throwable
| Exception（异常）<—RuntimeException<—ArithemeticException、Nullpointerexception... |
| Error （系统严重错误） |
先捕获具体的异常，后捕获宽泛的异常。
package yichangyuf; public class Hello { public static void main(String[]args){ try{ int num1 = 9; int num2 = 0; @SuppressWarnings("unused") int NUM = num1/num2; }catch(ArithmeticException ex){ System.out.println("it's ok!"); } } }
throws:
在方法的定义时使用，表明该方法有危险，调用需谨慎。
则在调用的时候需要try-catch处理。
1、调用危险方法时，当场处理。
public class Hellooo{ public static void main(String[]args){ A a = new A(); //1、调用危险方法时，当场处理 try{ a.hello(); }catch (IOException ex){ ex.printStackTrace(); } } } class A{ public void hello() throws IOException{ System.out.println(); } }
2、调用危险方法时，将异常上抛给调用者
ublic class Hellooo{ public static void main(String[]args) throws IOException{ A a = new A(); //2、异常上抛给定义者 a.hello(); } } class A{ public void hello() throws IOException{ System.out.println(); } }
throw：
public class Hellooo{ public static void main(String[]args) throws IOException{ B b = new B(); b.hello(); } } class B{ public void hello(){ System.out.println("hello world!"); try{ throw new IOException();//在内部引爆了一个炸弹 }catch(Exception ex){ } } }
向上抛出更大的异常
class B{ public void hello() throws Exception{ System.out.println("hello world!"); //try{ throw new IOException();//在内部引爆了一个炸弹 //}catch(Exception ex){ } }
自定义异常：
特定情况下的异常
class MyException extends Exception{
}
