java---杂七杂八的备忘录

记录从一些视频博客之类的学习到的一些经验,不断添加,当成自己的储备仓库

---

一,效率最高的两数交换代码

通过异或运算实现,属于有一定技巧性的代码,实际开发还是用常规的那种.(另外若是遇到n和m引用自同一个变量的情况的话,则会出错,n就相当于对自己做了三次异或运算)

    int n = 8,m = 9;
        n = n ^ m;
        m = n ^ m;
        n = n ^ m;
        System.out.println("N="+n+"M="+m);

二.java内存

分为堆内存和栈内存,栈内存主要保存变量,堆内存保存对象和数组.下面举个例子

int[] a = new int[5];

简单来说对于a是存放在栈内存,对于new int[5]是存放在堆内存,a只是对堆内存的引用,也就是说堆内存是new出来的东西,栈内存是定义出来的东西,而引用则是可以赋值为null的变量就是对堆内存的引用,这样一想,原来String的对象是引用啊

三.进制转换

如果程序中经常用到进制转换,应该用查表法写一个通性方法.

public static void toHex(int num) {
        int temp = 0;
        StringBuffer sb = new StringBuffer();
        int x = 0;
        while(++x<8){
        //转几进制则对进制的最大值按位与
            temp = num & 15;
            if (temp>9) {
                sb.append((char)(temp-10+'A'));
            }else {
                sb.append(temp);
            }
            num = num >>>4;

        }
        System.out.println(sb.reverse());
    }   

四.匿名对象的使用方式

1.当前对象只使用一次,不会在重复使用,这样使用匿名对象比较简介,当对象需要调用多个其方法,则必须建立对象名
2.对象作为实际参数来传递的时候

    Car a1 = new Car();
        a1.color = "RED";
        a1.show();
        //匿名对象的使用
        new Car().show();
        //匿名对象作为参数使用
        useCar(new Car());

五.构造代码块

1.作用: 给对象进行初始化,用于所有对象公用的初始化
2.执行时间: 一建立对象就执行,且优先于构造函数执行
3.和构造函数的区别: 构造代码块用于所有对象共同的初始化,构造函数只是针对于特定的这一种对象

class Car{
    //构造代码块先执行
    {
        System.out.println("我是代码块");
    }
    //构造函数在代码块之后执行
     public Car() {
        System.out.println("我是构造函数");
    }
}

六.this关键字在构造函数中的使用

this可以用于构造函数之间的调用,但是只能定义在构造函数的第一行,因为初始化需要先执行,否则报错

class Car{
    String name;
    int num;
     public Car() {
         name = "haha";
    }
     public Car(int num) {
         this();//调用无参的构造函数
         this.num = num;
     }
}

七.static关键字的用处和注意事项

1.特点:
A.随着类的建立而建立,随着类的消失而消失,并且存在于方法区内存中
B.优先于对象存在,先有静态变量,再有对象
C.被所有类成员共享,也就是在内存中只有一个
D.可以被类名直接调用
2.注意事项
A.静态方法只能访问静态成员,因为其在对象之前创建.非静态方法既可以访问静态成员也可以访问非静态成员,也可以用创建的先后顺序解释
B.静态方法中不可以用this,super关键字,原因还是本身先于对象创建
C.静态成员优点节省内存,缺点生命周期过长,访问有局限性(只能访问静态成员)

八.接口的规范化使用

接口中常见的定义有常量和抽象方法.其中每一类成员都有自己的固定的修饰符,
常量: public static final
方法: public abstract
接口就相当于对目前类的额外扩展

九.多态性详解

多态性的提现主要是父类的引用指向了子类,或者父类承载了子类
使用多态性的前提:
1.必须类和类之间有关系,要么继承,要么实现
2.通常还一个前提就是存在覆盖,这样使用多态才有意义.
使用多态性的弊端:
1.虽然提高了扩展性,但是只能使用父类的引用访问父类中的成员
2.多态性开发一般都会配合instanceof关键字来判断所属类型,这样就可以解决上述弊端
另外,多态牵扯到转型:
1.无论怎么转型都是对子类的转型,所以把父类转换成子类是大大不可取的做法

十.内部类能访问外部类的原因

内部类可以直接访问外部类中的成员,包括私有,是因为内部类持有了一个外部类的引用,格式为 外部类名.this.如果外部类要访问内部类,则必须要建立内部类的对象
另外内部类的使用一般是事务当中又包含了事务,因为类是对事务的描述,所以这样内部类才有意义

十一.多线程的start和run的区别

public static void main(String[] args){
        NewThread thread = new NewThread();
        thread.start();//调用start开启线程,并且运行子类复写的run方法
//      thread.run();//仅仅是对象的调用,虽然创建了线程,但是并没有运行该线程
    }
}
class NewThread extends Thread{
    @Override
    public void run() {
        System.out.println("AAAAAAAA");
    }

十二.线程同步代码的分析

同步代码可以防止因cup片段获取问题而带来的共享变量判断的错误问题,最简单的案例就是卖票的案例,这里不多说,
同步形式:

Object obj = new Object();
synchronized (obj) {
            //需要同步的代码
        }
        或者同步函数
    public synchronized void Test() {
        //同步代码块
    }

其中obj就相当于锁,获取锁的才可以进去运行.
同步的要求:哪里用到了共享变量哪里就要同步,所以也就是多线程的时候要注意同步问题,同时同步机制带来一定的资源消耗,因为每次运行线程都需要判断是否有锁.

十三.线程唤醒机制注意事项

wait()
notify()
notifyAll()
三个方法都是使用在同步中,被相应的锁调用即可,因为要对持有的监视器(锁)的线程操作,且只有同步中才有锁,所以要使用在同步中.

为什么这些操作线程的方法要定义在object中?
因为锁可以是任意对象,所以可以被任意对象调用的方法定义在object中

这些方法在操作同步线程的时候,都必须标识他们所操作的线程所持有的锁,因为同一个锁上的被等待线程可以被同一个锁上的notify唤醒,不可以对不同锁中的线程进行唤醒.

版权声明：本文为博主原创文章，未经博主允许不得转载。

 

转载于:https://www.cnblogs.com/-niuli/p/4856411.html