今天总算是把那个党员谈话给弄完了,三个学弟轮番跟我来聊天,讲自己的入党动机啥的,看到他们就仿佛看到了大一的自己,原来当时面对学长,面对这类事情,会紧张,会局促,被学长安慰了但是还是绷着的样子。哇咔咔,一晃眼啊,号称是人生中最令人迷醉的那段时间就快没了,研究生的时候可能就没这么写意的事情了。感伤~ 不如看Java,对了,我要推荐国漫--《一人之下》,很好看,很有趣,各路方言看着满满的土气,但这才是国漫吗。。虽然有的地方有点少儿不宜,但是真的很好看啊,简直把我想象中的小说结合现代漫画风格搬上了B栈,太好看了!
~(郑重声明:本文非原创,只是笔记,取自菜鸟编程!好东西,继续打CALL)~
========复习========
========复习========
Java语言提供了很多修饰符,主要分为以下两类:
修饰符用来定义类、方法或者变量,通常放在语句的最前端。
public class className {
// ...
}
private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;
public static void main(String[] arguments) {
// 方法体
}
Java中,可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Javav支持 4 种不同的访问权限。
*public : 对所有类可见。使用对象:类、接口、变量、方法
*protected : 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)。
我们可以可以通过以下表来说明访问权限:
修饰符 | 当前类 | 同一包内 | 子孙类 | 其他包 |
---|---|---|---|---|
public | Y | Y | Y | Y |
protected | Y | Y | Y | N |
default | Y | Y | N | N |
private | Y | N | N | N |
使用默认访问修饰符声明的变量和方法,对同一个包内的类是可见的。接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。
String version = "1.5.1";
boolean processOrder() {
return true;
}
public class Logger {
private String format;
public String getFormat() {
return this.format;
}
public void setFormat(String format) {
this.format = format;
}
}
public static void main(String[] arguments) {
// ...
}
Java 程序的 main() 方法必须设置成公有的,否则,Java 解释器将不能运行该类。
class AudioPlayer {
protected boolean openSpeaker(Speaker sp) {
// 实现细节
}
}
class StreamingAudioPlayer extends AudioPlayer {
protected boolean openSpeaker(Speaker sp) {
// 实现细节
}
}
请注意以下方法继承的规则(就是子类中的东西必须必父类更加开放,等同于人类的开放程度逐级递增的概念,当然,老爸私有的东西,儿子是没法继承的):
为了实现一些其他的功能,Java 也提供了许多非访问修饰符。
public class InstanceCounter
{
private static int numInstances = 0;
protected static int getCount()
{
return numInstances;
}
private static void addInstance()
{
numInstances++;
}
InstanceCounter()
{
this.addInstance();
}
public static void main(String[] arguments)
{
System.out.println("Starting with " + InstanceCounter.getCount() + " instances");
for (int i = 0; i < 500; ++i)
{
new InstanceCounter();
}
System.out.println("Created " + InstanceCounter.getCount() + " instances");
}
}
Started with 0 instances
Created 500 instances
final 变量能被显式地初始化并且只能初始化一次。被声明为final 的对象的引用不能指向不同的对象。但是 final 对象里的数据可以被改变。也就是说 final 对象的引用不能改变,但是里面的值可以改变。final 修饰符通常和 static 修饰符一起使用来创建类常量。
public class Test{
final int value = 10;
// 下面是声明常量的实例
public static final int BOXWIDTH = 6;
static final String TITLE = "Manager";
public void changeValue(){
value = 12; //将输出一个错误
}
}
类中的 final 方法可以被子类继承,但是不能被子类修改。声明 final 方法的主要目的是防止该方法的内容被修改。
public class Test{
public final void changeName(){
// 方法体
}
}
final 类不能被继承,没有类能够继承 final 类的任何特性。
抽象类不能用来实例化对象,声明抽象类的唯一目的是为了将来对该类进行扩充。一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法,那么该类一定要声明为--抽象类--,否则将出现编译错误。抽象类可以包含抽象方法和非抽象方法
```java abstract class Caravan{ private double price; private String model; private String year; public abstract void goFast(); //抽象方法 public abstract void changeColor(); }
* 抽象方法(类似于C++的虚函数吧)
* 抽象方法是一种没有任何实现的方法,该方法的的具体实现由子类提供。
抽象方法不能被声明成 final 和 static。
* 任何继承抽象类的子类必须实现父类的所有抽象方法,除非该子类也是抽象类。
* 如果一个类包含若干个抽象方法,那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
* **抽象方法的声明以分号结尾,例如:public abstract sample();**
java public abstract class SuperClass{ abstract void m(); //抽象方法 }
class SubClass extends SuperClass{ //实现抽象方法 void m(){ ......... } }
### 12、 synchronized 修饰符(简单点说就是上锁?)
synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符
### 13、 transient 修饰符(不大懂~)
* 序列化的对象包含被 transient 修饰的实例变量时,java 虚拟机(JVM)跳过该特定的变量。
* 该修饰符包含在定义变量的语句中,用来预处理类和变量的数据类型。
### 14、 volatile 修饰符
volatile 修饰的成员变量在每次被线程访问时,都强制从共享内存中重新读取该成员变量的值。而且,当成员变量发生变化时,会强制线程将变化值回写到共享内存。这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个值。一个 volatile 对象引用可能是 null。
java public class MyRunnable implements Runnable { private volatile boolean active; public void run() { active = true; while (active) // 第一行 { // 代码 } } public void stop() { active = false; // 第二行 } } ``` 通常情况下,在一个线程调用 run() 方法(在 Runnable 开启的线程),在另一个线程调用 stop() 方法。 如果"第一行"中缓冲区的 active 值被使用,那么在"第二行" 的 active 值为 false 时循环不会停止。但是以上代码中我们使用了 volatile 修饰 active,所以该循环会停止。
总体来说,Java的两类修饰符,一类访问控制符,侧重于对访问权限的控制,规定在哪儿可以访问我修饰的这个东西;而非访问控制符的话,更多就是侧重于修饰功能,是对于变量或者方法的一种补充,比如static就规定了不论类有多少对象,只有这么一个变量公用。这就是性质的变化,而不是访问权限的变化。所以还是很好理解的!!