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

  1. 云栖社区>
  2. 博客>
  3. 正文

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

云栖-lxl 2012-12-25 17:18:00 浏览535
展开阅读全文

基础知识的总结
数据类型:基本数据类型和引用数据类型
基本数据数据类型(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();
      }
}

网友评论

登录后评论
0/500
评论
云栖-lxl
+ 关注