java日常学习

PS:xp上的火狐真好用。。。360极速浏览器的chrome在xp上居然支持到69，我太高兴了。。。配合上xshell5链接服务器，再加上学生机上部署的code-server，梦回2010失败。^^

窝在家里的日常

Java访问控制符的含义和使用情况

本类本包子类外部包
public √ √ √ √
protected √ √ √ X
default √ √ X X
private √ X X X

方法和方法之间的调用

静态方法

本类中： 静态方法：可以直接调用
非静态方法：不可以直接调用，要通过创建对象调用
不同类中： 静态方法：导入包，类名.静态方法()
非静态方法：导入包，创建对象，调用

非静态方法

本类中： 静态方法：可以直接调用
非静态方法：可以直接调用
不同类中： 静态方法：导入包，类名.静态方法()
非静态方法：导入包，创建对象，对象名.非静态方法()

写到这里其实感觉，静态方法就是Java类的一个属性，是直接属于类里面的，所以在静态非静态方法里都可以直接调用，非静态方法是一个额外的，附属于对象的，所以要通过新建对象来使用。

Example：

public class test{
    private int x = 0;
    public static int y = 6;//静态方法调用的时候只能调用静态变量
    public static void main(String[] args){
        test T = new test();//调用自己的类
        testPrint();//直接本类的调用静态方法
        test.testPrint();//类名调用静态方法
        test doge = new test();//两个构造器
        test cate = new test(10);        
        System.out.println(T.f("Mhrooz"));
        B b = new B();//调用其他的类
        B.PrintDefault();//调用静态函数
        b.printValue();
        b.setValue(5);
        b.printValue();
    }
    public test(int x)//调用构造器 at 7 line.
    {
        this.x = x;
        System.out.println("Test here is "+this.x);
    }
    public test()//调用构造器 at 6 line.
    {
        this(1); //this must at the first line.
        /*
            this(2); //If it is at second line,this is also wrong.
        */
        System.out.println("Get it");        
        System.out.println("Test here is "+this.x);
    }
    public static void testPrint()
    {
        System.out.println(y+5);//调用静态变量
    }
    public long f(int x){//递归调用实现阶乘
        if(x == 1)  return 1;
        return x * f( x - 1 );
    }
    public long f(String s)
    {
        return (long)s.charAt(0);
    }
}

class B{
    private int value = 0;
    private static int defaultValue = 6;
    public static void PrintDefault()
    {
        System.out.println(defaultValue);
    }
    public void setValue(int x){
        value = x;
    }

    public void printValue(){
        System.out.println(value);
    }

}

导入导出包&命令行编译运行

1.导入包中的所有类

import name.*

name表示包的名字

2.导入包中的部分类

import name.class

name表示包的名字，class表示类的名字

3.编译包

javac -d . name.java

-d表示创建目录，.表示当前文件夹，后面是文件名，注意中间有空格

4.运行包

java packagepath/class

packagepath表示包路径，最后加上含有main的类

打包运行指令，第一个是编译，第二个是运行
//上述的编译源代码
package xyz.mhrooz;
public class Package{
    public static void main(String[] args){
        System.out.println("Test package");
        test.cal(5);
    }
}

class test{
    private static int x = 5;
    public static int cal(int y){// calculate y + 5
        System.out.println("Your number is "+y);
        return x + y;
    }
}

动态链接

向上转型

父类的引用指向子类。

动态链接是Java的一种特性，具体实现就是，父类的引用指向子类后，不能使用子类自有的方法，而可以使用子类重载父类的方法。

package com.father;
public class father{
    public void say(){
        System.out.println("Father say: Wow !");
    }
    public static void main(String[] args){
        System.out.println("Who says?");
        father F = new son();//向上转型
        F.say();//输出Son say
    }

}

class son extends father{
    public void say(){
        System.out.println("Son say: NO!~");
    }
}
输出
Who says?
Son say: NO!~

如果父类方法是静态的，那么执行的还是父类的方法，这个叫做静态绑定

对象群体的组织

7.1 对象数组

数组

· 效率最高的随机访问序列

· 类型检查

· 边界检查

· 动态性差

集合

· 可动态改变大小

· 可以在序列中储存不同类型的数据

集合

把具有相同性质的一类东西，汇聚成一个整体

在Java2中有很多与集合相关的接口及类

▲不能存放基本数据类型，只能存放对象

集合框架(JAVA COLLECTIONS FRAMEWORK)

为表示和操作集合而规定的一种统一的标准的体系结构

提供了一些现成的数据结构可供使用，程序员可以利用集合框架快速编写代码，并获得优良性能

包含三大块内容

Ø对外的接口：表示集合的抽象数据类型，使集合的操作与表示分开

Ø接口的实现：指实现集合接口的Java类，是可重用的数据结构

Ø对集合运算的算法：是指执行运算的方法，例如在集合上进行查找和排序

集合框架接口

声明了对各种集合类型执行的一般操作

包括Collection、Set、List、SortedSet、Map、SortedMap

Java集合主要包括三种类型：Set(集)，List(列表)，Map(映射)。

image-20200313162704908

COLLECTION接口

声明时可以使用一个参数类型，即Collection<E>

声明了一组操作成批对象的抽象方法：查询方法、修改方法

查询方法

 int size() – 返回集合对象中包含的元素个数
 ​
 boolean isEmpty() – 判断集合对象中是否还包含元素，如果没有任何元素，则返回true
 ​
 boolean contains(Object obj) – 判断对象是否在集合中
 ​
 boolean containsAll(Collection c) – 判断方法的接收者对象是否包含集合中的所有元素

修改方法

 boolean add(Object obj) – 向集合中增加对象
 ​
 boolean addAll(Collection<?> c) – 将参数集合中的所有元素增加到接收者集合中
 ​
 boolean remove(Object obj) –从集合中删除对象
 ​
 boolean removeAll(Collection c) -将参数集合中的所有元素从接收者集合中删除
 ​
 boolean retainAll(Collection c) – 在接收者集合中保留参数集合中的所有元素，其它元素都删除
 ​
 void clear() – 删除集合中的所有元素

SET接口

Ø扩展了Collection

Ø禁止重复的元素，是数学中“集合”的抽象

Ø对equals和hashCode操作有了更强的约定，如果两个Set对象包含同样的元素，二者便是相等的

Ø实现它的两个主要类是哈希集合(HashSet)及树集合(TreeSet)

SORTEDSET接口

Ø一种特殊的Set

Ø其中的元素是升序排列的，还增加了与次序相关的操作

Ø通常用于存放词汇表这样的内容

SET的一般用法

Set集合中存放的是对象，并且没有重复对象。

Java中实现Set接口的类很多，至于该用哪个，我们不用区分，我们只对接口负责。

 Set set = new HashSet();

这样就创建了一个集合对象，我们把它当作抽象的集合接口看待。

使用接口的好处在于，实现类将来可以被替换，而程序不用做很多改动。

例：Set集合依次把三个引用变量加入到集合中

 Set<String>  set=new HashSet<String>();
 String  s1=new  String(“Hello”);
 String  s2=new  String(“Hello”); 
 String  s3=new  String(“World”);
 set.add(s1);
 set.add(s2);
 set.add(s3);
 System.out.println(set.size());   //对象的数目为2
 Set<String>  emp=new HashSet<String>();
 emp.add("Tom");
 emp.add("Mike");
 emp.add("Jack");
 emp.remove("Tom");
 emp.remove("Jack");
 emp.add("Linda");
 System.out.println(emp.size());   //对象的数目为2
 ​

HASHSET类

HashSet类按照哈希算法来存取集合中的对象，具有很好的存取和查找性能。

当向集合中加入一个对象时，HashSet会调用对象的hashCode()方法来获得哈希码，然后根据哈希码进一步计算出对象在集合中的位置。

ITERATOR类

Iterable：实现这个接口的集合对象支持迭代，是可以迭代的。实现了这个可以配合foreach使用。

Iterator：迭代器，提供迭代机制的对象，具体如何迭代是这个Iterator接口规范的。包含三个方法：hasNext、next、remove，remove一般很少用到。

如果集合中的元素没有排序，Iterator遍历集合中元素的顺序是任意的，并不一定与集合中加入元素的顺序是一致的。

Iterator功能比较简单，并且只能单向移动：

1.使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterator()方法是java.lang.Iterable接口,被Collection继承。

2.使用next()获得序列中的下一个元素。

3.使用hasNext()检查序列中是否还有元素。

4.使用remove()将迭代器新返回的元素删除。

Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。

TREESET类

TreeSet采用树结构来存储数据，它中的每个元素成为一个节点，节点会按照其存放数据的“大小”顺序，一层一层地依次排列，对于同一层中的节点从左到右按“大小”顺序递增排列，下一层的都比上一层的小。

TreeSet类实现了SortedSet接口，能够对集合中的对象进行排序

 package collection.set;
 import java.util.*;
 public class HashSetComp2 {
     public static void main(String[] args) {
         Set<Integer> set = new TreeSet<Integer>();
         set.add(new Integer(8));
         set.add(new Integer(6));
         set.add(new Integer(7));
         Iterator<Integer> it = set.iterator();
         while (it.hasNext()) {
              System.out.println(it.next() + " ");
         }
     }
 }

当向集合中加入一个对象时，会把它插入到有序的对象集合中。

TreeSet支持来两种排序方式：

Ø自然排序

Ø客户化排序

默认情况下采用自然排序。

自然排序

在JDK类库中，有一部分类实现Comparable接口，如Integer、Double和String等

Comparable接口有一个compareTo(Object o)方法，它返回整数类型。

对于表达式x.compareTo(y)，

Ø如果返回值为0，则表示x和y相等

Ø如果返回值大于0，则表示x大于y

Ø如果返回值小于0，则表示x小于y

TreeSet调用对象的compareTo()方法比较集合中对象的大小，然后进行升序排列，这种方式称为自然排序。

正常是按升序排列，在返回前面加个负号就可以降序排列

JDK类库中实现了Comparable接口的一些类的排序方式。

类 排序
Byte、Double、Float、Integer、Long、Short 按数字大小排序
Character 按字符Unicode值的大小排序
String 按字符串中字符的Unicode值的大小排序

使用自然排序时，只能向TreeSet集合中加入同一类型的对象，并且这些对象必须实现Comparable接口。

compareTo返回类型必须是int类型，否则系统将判断这是一个新函数。

 package collection.set;
 import java.util.*;
 class Point implements Comparable{
     private int x;
     private int y;
     public Point(int x,int y){
              this.x=x;
               this.y=y;
     }
     public String toString(){
                return "<"+x+","+y+">";
     }
     public int compareTo(Object obj){
                 if(obj instanceof Point){
                           Point p=(Point)obj;
                            return (x*1000+y)-(p.x*1000+p.y);
                 }else{
                            return -1;
 }}}
 public class HashSetPointComp1 {
     public static void main(String[] args) {
                   Set<Point> s=new TreeSet<Point>();
                   s.add(new Point(2,1));
                   s.add(new Point(1,1));
                   s.add(new Point(2,2));
                   s.add(new Point(1,2));
                   Iterator<Point> it=s.iterator();
                   while(it.hasNext()){
                                                       Point p=it.next();
                               System.out.println(p.toString());
 }}}
 ​

1条评论

留下评论

您的电子邮箱地址不会被公开。 必填项已用*标注

此站点使用Akismet来减少垃圾评论。了解我们如何处理您的评论数据。