//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中,类只支持单继承,不允许多继承。
重写父类方法:
//重写父类 /* * 只会调用子类重写的方法 */ 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 /* * 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 */
抽象类和接口:
//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 */