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唤醒,不可以对不同锁中的线程进行唤醒.

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