1、同一个类中只能有一个public修饰符；
2、类变量和成员变量的区别（即静态变量和非静态变量的区别）：
（1）类变量即类的属性，就是静态修饰的变量，他们被类的实例所共享，就是说一个实例改变了他们的值，那么其他的实例也会受到影响。
如下代码：
class person（2）成员变量则是实例私有的，只有实力本身可以改变它的值；
{
static String str1;
//静态方法中修改静态变量的值
public static void alter1(String str11)
{
str1=str11;
}
}
public class HelloWorld {
public static void main(String[] args) {
person p1=new person();//创建一个P1对象，将其实例化
p1.alter1("hha");//调用静态方法修改静态变量的值
person p2=new person();//创建另一个p2对象，将其实例化
System.out.println(p2.str1);//此时p2的静态变量的值也被改变；
}
}
3、类的封装：
即将成员变量设置为private，然后通过setXX ()等public方法来修改成员变量，这样对象就不能直接访问成员变量；
4、类的继承：
（1）extends关键字，eg：Class student extends teacher{}
（2）super关键字：用于调用父类的属性或方法；
（3）覆写：即子类的某个方法与父类的那个方法的名称、参数、返回值都一样，此时调用子类的方法就会覆盖父类的方法；不过可以通过在子类的方法里调用super来调用父类的方法；
如下代码：
class father1（4）重载和覆写的区别：
{
int i=1;
public void set()
{
this.i=11;
}
}
class child2 extends father1
{
public void set()
{
this.i=2;
System.out.println(i);//此时输出2
super.set();
System.out.println(i);//此时输出11；
}
}
public class extend2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
child2 c=new child2();
c.set();
}
}
重载是指方法在一个类里的多种表现形式（参数或返回值不同）；
覆写是指子类中的方法覆盖父类中的方法（参数和返回都一样）；
（5）抽象类的定义：
a. 抽象类和抽象方法都必须用abstract关键字修饰（抽象类中也可以有构造函数和一般的方法，即实现好的方法）；
b. 抽象类不能被直接实例化，也就是不能直接用new关键字去产生对象；
c.抽象方法只需声明，不需要实现；
d.含有抽象方法的类必须被声明为抽象类，抽象类的子类必须覆写所有的抽象方法后才能被实例化，否则这个子类还是个抽象类；（这句话的意思是：子类中必须将抽象类中声明的方法进行实现，否则创建的对象将没法调用方法，从而出错）如下代码：
//抽象类不能被实例化，即不能直接用new去创建对象（6）接口：interface（比如，给你个接口，你进行调用里面的数据，但是却不能修改），和抽象类非常相似，下面的是不同点：
abstract class father
{
int i;
public father()
{
i=10;
}
public abstract void set();//方法只声明不实现，也可以实现；
}
class sub extends father//继承自抽象类father
{
public void set()
{
i=2;
System.out.println(i);//此时输出2
}
public void print()
{
System.out.println(i);
}
}
public class abstract1 {
public static void main(String[] args) {
sub s=new sub();
s.set();
s.print();
}
}
a.接口里的数据成员必须初始化，且值不可修改（否则出错），其中final关键词可以省略
b.接口里的方法必须全部声明为abstract，也就是说，接口不能像抽象类一样保有一般的方法，必须全部是抽象方法，其中abstract关键词可以省略
c.接口中的域（即成员变量）默认都是static、final、public类型的，且一般都是大写，eg:int JANUARY = 1;
如下代码：
//下面是接口例子下面代码是接口应用场景：
interface parent//不能写class，只写个interface
{
int i=20;//必须初始化，且值不可更改，其中的final关键词可以省略
public void set();//其中的abstract关键词可以省略
}
class child implements parent//用implements关键字
{
public void set()//必须对接口中的方法进行实现
{
System.out.println(i);
}
}
public class interfaceTest
{
public static void main(String[] args)
{
child s=new child();
s.set();
}
}
//----------接口应用场景----------
interface usb
{
public void start();
public void stop();
}
class Mp3 implements usb
{
public void start()
{
System.out.println("Mp3 is running");
}
public void stop()
{
System.out.println("Mp3 is able to stop");
}
}
class Mp4 implements usb
{
public void start()
{
System.out.println("Mp4 is running");
}
public void stop()
{
System.out.println("Mp4 will be stopped");
}
}
class computer
{
public void work(usb s)
{
s.start();
s.stop();
}
}
public class interfaceTest
{
public static void main(String[] args)
{
new computer().work(new Mp3());
new computer().work(new Mp4());
}
}
（7）匿名对象：只使用一次，然后就被Java的垃圾收集器回收；
eg：new person().set();//调用person类下面的set方法
（8）静态代码块：static
当类被载入时执行，发生在构造函数之前，常用来初始化类的属性
如下代码：
//静态代码块的执行顺序
class person1
{
public person1()
{
System.out.println("construct run");
}
static
{
System.out.println("static run");
}
}
public class staticCodeBlock
{
public static void main(String[] args)
{
new person1();//程序先输出static的内容，再输出构造函数的内容
}
}
（9）final关键字：
a、final标记的类不能被继承
b、final标记的方法不能被子类覆写
c、final标记的变量为常量，只能赋值一次
（10）instanceof关键字：
语法格式：“对象 instanceof 类或接口”
可以用来判断一个类是否实现了某个接口，也可以判断一个实例对象是否属于一个类；
如下代码：
//instanceof的用法
class parent1
{
}
class child1 extends parent1
{
}
public class instanceofTest
{
public static void main(String[] args)
{
parent1 p=new child1();
if(p instanceof child1)//结果为true
System.out.println("p belong child1 class");
else
System.out.println("p not belong child1 class");
}
}