黑马程序员java笔记之零-----基础知识

基础知识的总结
数据类型：基本数据类型和引用数据类型
基本数据数据类型（boolean.byte.short.int.lang.float.double.char）
引用类型（类、接口、数组）
重载（overLoad）和重写(override)
重载满足要素：方法名相同、参数的类型和参数的个数不同,和方法返回值、修饰符等无关
重写满足要素：方法名相同、形参列表相同、返回值类型比父类返回值更小或相等、访问权限比父类方法更大或相等
java的标示符规则：
1.字母、数字、下划线、美元符号，并且不能以数字开头
2.标示符不能为java的关键字和保留字符（goto）
基本类型转换字符串的方法：
基本类型转换成字符串的的方法：
第一种：String.valueof(基本类型)
第二种：空字符串加上基本类型，得到基本类型字符串（这里是空字符串不是空格字符串）
第三种：调用对象的toString（）
字符串转换成基本类型的两个方法：
1、调用基本类型封装类的paresexxx静态方法
2、用字符串构造基本类型，再调用封装对象的xxxValue方法
------------------------------------
Set set = hashMap.keySet();
//问题1：hashMap.keySet方法返回一个Set对象，Set是接口，
//接口可以有引用，并指向其子类对象。但是怎么可以有一个引用set指向自己的对象呢？
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Set;

public class CollectionDemo {

public static void main(String[] args) {

Person p1 = new Person(21);
Person p2 = new Person(23);
Person p3 = new Person(21);

HashMap hashMap = new HashMap();
hashMap.put("zhangsan", p1);
hashMap.put("lisi", p2);
hashMap.put("wangwu", p3);

Set set = hashMap.keySet();
//问题1：hashMap.keySet方法返回一个Set对象，Set是接口，
//接口可以有引用，并指向其子类对象。但是怎么可以有一个引用set指向自己的对象呢？
Iterator i = set.iterator();
while(i.hasNext()){
String s = i.next();//这里提示错误，应该把s的类型改为person
//问题2：i.next方法应该返回一个String，这里为什么会报错？
解答：其实在java的hashMap中还有一个内部类，这个类就是keySet
你可以在你的代码中用 System.out.println(hashMap.keySet().getClass().getName())试试看，
返回的java.util.HashMap$KeySet，这就代表Set通过keySet方法获得的Set对象其实是hashMap的内部类实例。而对于注释部分的keySet，因为keySet其实只需要有一个就可以了，因为每个hashMap集合只可能有一种key队列，多了就浪费空间了，所以除了第一次会new一个新的对象，你再次调用，就把以前已经创建的keyset对象给你
//并提示应该把s的类型改为person？
System.out.println(i.next());//而这里直接打印出的又是person。
解释：②因为你没有加泛型限定，所以i.next返回的是Object类型的，必须要进行强转或者对迭代器进行类型限定，你这里就限定成String类型
}
}
}

Constructor[] constructors=Class.forName("java.lang.String").getConstructors();
---------------------------------------------------------------------------------
synchronized：在代码里，synchronized类似“面向对象”，修饰类、方法、对象
Lock：不作为修饰，类似“面向过程”，在方法中需要锁的时候lock，在结束的时候，unlock（一般在finally块里）
代码：
public void metho(){
synchronized(this){//旧锁，无须人工释放
System.out.println(1);
}
}

public void method2(){
Lock lock=new ReentrantLock();
lock.lock();//上锁
try{
System.out.println(2);
}finally{
lock.unlock();//解锁
}
synchronzied--对象加锁：
所有对象都自动含有单一的锁，jvm负责跟踪对象被加锁的次数。如果一个对象被锁，其记数变为0。在任务（线程）第一次给对象加锁的时候，记数变为1。每当这个相同的任务（线程）在此对象上获得锁时，记数会递增。只有首先获得锁的任务（线程）才能继续获取该对象上的多个锁。每当任务离开时，记数递减，当记数为0的时候，锁被完全释放。sychronized就是基于这个原理，同时synchronized考某个独享的单一锁技术的次数来判断是是否被锁，所以无需（也不能）人工干预锁的获取和释放。

}
Lock---基于栈中的框架，而不是对象级别：
lock不同于synchronized,它基于栈中的框架而不是某个具体对象，所以Lock只需在栈里设置锁的开始和结束（lock和unlock）的地方，就行了（人工必须注明），不需要关心框架大小对象的变化等等。这么做的好处是Lock能提供无条件的、可轮询的、定时、可中断的锁获取操作，相对于synchronized来说，synchronized的锁的获取和释放不在一个模块里，获取和释放的顺序必须相反，而Lock则可以在不同范围内获取释放，并且顺序无关。

------------------------------------------------------------------
TreeSet的排序方式有下面两种：
1：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。
也种方式也成为元素的自然顺序，或者叫做默认顺序。
class Student implements Comparable//该接口强制让学生类具备比较性
{ Student()
{}
public int compareTo(Object obj)
{}
}

2：当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。
在集合初始化时，就有了比较方式。
这时就需要定义一个比较器类去实现Comparator，并重写compare方法。
class MyCompare implements Comparator //自定义比较器，使集合具备比较性
{ public int compare(Object o1,Object o2)
{}
}

在定义集合时，需要根据实际情况选择排序方式：
1、TreeSet ts =new TreeSet(); //此时的排序方式为第一种，即元素的自然排序方式。
2、TreeSet ts =new TreeSet(new MyCompare()); //此时的排序方式为第二种，即集合自身具备比较性。
---------------------------------------------------------------------------------------------
Set:无序，不可以重复元素
|---Hashset:数据结构式哈希表。线程是非同步的。
包成元素唯一性的原理：判断元素的hashCode值是否相同
如果相同，还会继续判断元素的equals方法，是否为true。
采用hash表
|---Treeset:可以对Set集合中的元素进行排序
底层数据结构式二叉树
保证元素唯一性的依据：
compareTo方法 return ();和hash表没关系
TreeSet排序的第一种方式：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法
这种方式也成为元素的自然排序，或者叫做默认排序。
注意：排序时，当主要条件相同时，一定判断一下次要条件。当对象很多时，耗时。
treeset采用二叉树形式保存数据!保存数据后查询的时候采用折半查询
TreeSet排序的第二种方式：
当元素自身不具备比较性时，或者具有的比较性不是不是所需要的。
这时就需要让集合自身具备比较性，定义比较器，将比较器对象作为参数传递给TreeSet集合的构造函数
在集合初始化时，就有了比较方式。
----------------------------------------------------------------------------------------------

解释是这样的，当你往集合中添加第一个元素的时候，（不管你重写不重写）集合都会自动调用hasCode方法，算出一个哈希值
当你再往集合中添加元素时。系统会再算出此元素的哈希值，并自动判断跟之前元素的哈希值是否相同。如果相同，就需要equals方法，来判断元素的属性是否都一样。
给你举个例子

元素要往哈希表结构的容器中存储，必须具备hashCode和equals方法。(Object已经提供了这两个方法。 对象创建在堆内存中就是因为有了hashCode方法.)
//覆写hashCode方法的原因。Object中的hashCode是本地(windows)方法，只算内存地址.
//不覆写会根据内存地址判断资料相同的人不是同一个人。
//满足不了人的姓名和年龄相同 既为同一个人的要求。所以要依据对象自身特别不同。

//覆写equals的原因:HashSet判断元素唯一的依据是自动调用equals方法。
//不覆写的话，如果hash值万一相同的话，就需要逐个比较元素的属性，而原来的equals满足不了这个要求
代码如下：
@Override
// 覆写hashCode方法的原因。Object中的hashCode是本地(windows)方法，只算内存地址.
// 不覆写会根据内存地址判断资料相同的人不是同一个人。
// 满足不了 人的姓名和年龄相同 既为同一个人的要求。所以要依据对象自身特别不同。
public int hashCode() {
final int prime = 31;
return name.hashCode() + age * prime;
// *prime的原因。防止姓名的哈希值是40,年龄是20 与姓名的哈希值是20,年龄是40 。而引起哈希值相同，多运行equals方法
}

@Override
// 覆写equals的原因:HashSet判断元素唯一的依据是自动调用equals方法。
// 不覆写的话，如果hash值万一相同的话，就需要逐个比较元素的属性，而原来的equals满足不了这个要求，
//如果主方法中添加的元素内容不是一模一样的，几乎不可能调用equals方法。
-----------------------------------------------------------------------------------------------
/首先，内部类其实就是一个子类对象
//其实内部类的出现，在一定意义上实现了多继承。因为内部类 可以有多个，分别继承别的类。外部类也可以用内部类里的方法了。
//然后，关于你的问题。子类如果想继承抽象内部类，就必须在这个类中定义一个带有外部类对象的构造方法，并在构造方法中调用外部类.super();

代码如下：
class Outer {
abstract class Inner {
abstract void show();
public void print() {
}
}
}
class Test extends Outer.Inner {// 如果不这么继承，必须导入Inner类的包。
Test(Outer out) {
out.super();
}
@Override
void show() {
}
}
两外一种解释：
class AbstractTest { //这里类修饰符可以使用abstract 修饰
static abstract class A{
/* A作为抽象类，那么static 必须保留，做为类静态成员变量。 A内部类，为外部类AbstractTest 的一个成员属性，随着对象的创建而加载，不能直接调用内部类，要调用只能new AbstractTest ().A。要想继承的话，只能把内部类改成静态内部类，static abstract class A {}，此时对着类的加载而加载。*/
abstract void say();
}

void c(){
System.out.println("sss");
}

}
class B extends AbstractTest.A{
public static void main(String[] args){

}

@Override
void say() {
// TODO Auto-generated method stub
}
}
重点：非静态内部类，伴随着类的实例化开辟内存单元。 A抽象内部类，为外部类AbstractTest 的一个成员属性，随着对象的创建而加载，不能直接调用内部类，要调用只能new AbstractTest ().A。要想继承的话，只能把内部类改成静态内部类，static abstract class A {}，此时对着类的加载而加载。
---------------------------------------------------------------------------------
--------- javac ----------
Main.java:11: 错误: 需要包含Outer.InnerAbs的封闭实例
class AA extends Outer.InnerAbs
^
1 个错误
为什么会产生这样的错误？
能不能修改这个错误，同时还能保证AA能够继承Outer.InnerAbs ？
-----------------------------

编译器的意思是：要创建Outer.InnerAbs的子类对象必须保留一个外部类的引用。

原理如下：
当创建一个子类时，子类构造函数总会调用父类的构造函数，因此在创建
非静态内部类的子类时，必须保证让子类构造函数可以调用非静态内部类
的构造函数，调用非静态内部类的构造函数时，必须存在一个外部类对象，
因为当调用非静态内部类的实例方法时，必须有一个非静态内部类实例，
而非静态内部类实例必须寄存在外部内实例里。

代码可以修改如下：
class Outer
{
int a=90;
public abstract class InnerAbs
{
int b=80;
abstract void inAbs();
}
}

class AA extends Outer.InnerAbs
{
//显式定义AA（非静态内部类子类）的构造函数
AA(Outer out)
{
out.super();
}

void inAbs()
{
System.out.println("AA……inAbs");
}
}

class Main
{
public static void main(String[] args)
{
Outer out = new Outer();
//非静态内部类子类的创建
AA aa = new AA(out);
aa.inAbs();
}
}