//static 关键字 静态变量&&静态方法
import java.io.*;
import java.math.*;
class person{
public static void fint()
{
System.out.println("object will gc!!!");
}
}
public class aaa{
public static void main(String[] args)
{
person p1= new person();
p1.fint();
}
}
//object will gc!!!
//成员内部类
package qqq;
import java.io.*;
import java.math.*;
class outer{
private int num=4;
public void test()
{
inner iner= new inner();
iner.show();
}
class inner{
void show()
{// 在成员内部类的方法中访问外部类的成员变量
System.out.print("num="+num);
}
}
}
public class aaa{
public static void main(String[] args)
{
outer p1=new outer();
p1.test();
}
}
/* ouput
* 测试类的静态代码块执行了
person 类中的静态代码块执行了
*
*/
//成员内部类
package qqq;
import java.io.*;
import java.math.*;
class outer{
private int num=4;
public void test()
{
inner iner= new inner();
iner.show();
}
class inner{
void show()
{// 在成员内部类的方法中访问外部类的成员变量
System.out.print("num="+num);
}
}
}
public class aaa{
public static void main(String[] args)
{
//创建外部类对象，调用show方法
outer p1=new outer();
p1.test();
//创建内部类对象 ，调用show方法，如果使用private 修饰inner,则无法编译
outer.inner p2= new outer().new inner();
p2.show();
}
}
/* ouput
* num=4
*
*/
<span style="font-family: Arial, Helvetica, sans-serif;">//类的继承</span>
/* * 子类会继承父类时候，会自动拥有父类的所有成员 * */class Animal{String name;//定义name属性void shout(){//定义动物叫的方法System.out.println("nice!");}}class dog extends Animal//定义dog类继承Animal类{public void printname(){System.out.println("name" + name);}}public class aaa{public static void main(String[] args){dog dg = new dog(); //创建一个dog的实例化对象dg.name = "a cute dog";dg.printname(); //调用dog类的方法dg.shout(); //调用dog类继承的方法}}/* * ouput: * namea cute dog nice! */
【注意】：在Java中，类只支持单继承，不允许多继承。
重写父类方法：
//重写父类【super关键字】：
/*
* 只会调用子类重写的方法
*/
class Animal
{
String name;//定义name属性
void shout(){//定义动物叫的方法
System.out.println("nice!");
}
}
class dog extends Animal//定义dog类继承Animal类
{
void shout(){
System.out.println("name" + name);
}
}
public class aaa
{
public static void main(String[] args){
dog dg = new dog(); //创建一个dog的实例化对象
dg.name = "a cute dog";
dg.shout(); //调用dog类重写的的方法
}
}
/*
* ouput:
* namea cute dog
*/
//super
/*
* super关键字调用父类重写方法
*/
class Animal
{
String name;//定义name属性
void shout(){//定义动物叫的方法
System.out.println("nice!");
}
}
class dog extends Animal//定义dog类继承Animal类
{
void shout(){ //访问父类的成员方法
super.shout();
}
}
public class aaa
{
public static void main(String[] args){
dog dg = new dog(); //创建一个dog的实例化对象
dg.name = "a cute dog";
dg.shout(); //调用dog类重写的的方法
}
}
/*
* ouput:
* nice!
*/
//super/* * super关键字调用父类重写方法 */class Animal{String name;//定义name属性public Animal (String name){//定义有参构造方法System.out.println("I am a "+name);}}class dog extends Animal//定义dog类继承Animal类{ public dog(){ //访问父类的有参构造方法 super("cute dog");}}public class aaa{public static void main(String[] args){dog dg = new dog(); //实例化子类dog的对象}}/* * ouput: * I am a cute dog */【注意】子类在实例化的时候默认调用了类的父类的无参的构造方法，尽量在类中定义一个无参的构造方法，避免被继承时出现错误。
final关键字修饰变量
//final
/*
* final关键字:
* final 修饰的类不能被继承
* final 修饰的方法不能被子类重写
* final修饰的变量（成员变量和局部变量）是常量，只能赋值一次
*/
class Animal
{
final String name="dog";//final 修饰name属性
public void shout(){//
System.out.println("I am a "+name);
}
}
public class aaa
{
public static void main(String[] args){
Animal dg = new Animal();
dg.shout();
}
}
/*
* ouput:
* I am a dog
*/
【注意】：final关键字修饰成员变量时，虚拟机不会对其进行初始化，因此使用final修饰成员变量时，需要赋初始值。
抽象类和接口：
//abstract and interface
/*
* abstract抽象类:
* interface接口类：
*/
abstract class animal{
abstract void mao();
}
class catt extends animal{
void mao(){
System.out.println("miao miao..");
}
}
public class aaa
{
public static void main(String[] args){
catt ct=new catt();
ct.mao();
}
}
/*
* ouput:
* miao miao..
*/
//abstract and interface
/*
* abstract抽象类:
* interface接口类：
*/
interface Animal
{
int id=1;
void breathe();
void run();
}
class dog implements Animal{
public void breathe(){
System.out.println("dog is breathe");
}
public void run(){
System.out.println("dog is running");
}
}
public class aaa
{
public static void main(String[] args){
dog dg = new dog();
dg.breathe();
dg.run();
}
}
/*
* ouput:
* dog is breathe
dog is running
*/