1 Hello world例子
- package Example; //定义自己的包名
- public class Example1 //定义一个类
- {
- public static void main(String[] args) //系统可以执行的main方法,这里是一个公有静态无返回值的方法
- {
- System.out.println("Hello world!");
- //调用java.lang包中的System类的PrintLine方法输出Hello world!
- }
- }
2 类的基本组成示例
- package Example;
- class Person
- {
- public int age; //声明公共字段age
- private String name; //声明私有字段name,此时name为类的属性,下面通过公有方法进行访问
- public String getName() {
- return name;
- }
- public void setName(String name) {
- this.name = name;
- }
- public void eat() //定义无参数的eat方法
- {
- System.out.println("Person can eat");
- }
- public void eat(String s) //定义带参数的eat方法,实现方法重载
- {
- System.out.println("Person can eat"+s);
- }
- public Person() //定义无参构造函数,注意无返回值定义,方法与类同名
- {
- }
- public Person(int age, String name) //重写一个带参数构造函数,注意无返回值定义,方法与类同名
- {
- this.age = age; //前一个age为对象的字段,由this指定,后一个age为函数形参
- this.name = name; //前一个name为对象的属性,由this指定,因为在本类中可直接访问,后一个name为函数形参
- }
- }
- public class Example2
- {
- public static void main(String[] args)
- {
- Person person1 = new Person(); //调用类的无参构造函数
- person1.age = 20; //给对象的公有字段直接赋值
- person1.setName("zhangsan"); //必须使用公共方法才能给对象的属性赋值
- System.out.println("第一个人信息,姓名:"+person1.getName()+"年龄:"+person1.age);
- person1.eat(); //调用对象的无参方法
- Person person2 = new Person(18, "lisi");//调用类的有参构造函数
- System.out.println("第二个人信息,姓名:" + person2.getName() + "年龄:" + person2.age);
- person2.eat(" 馒头"); //调用对象的有参方法
- }
- }
3静态与非静态变量及方法的使用
- package Example;
- class Example3
- {
- public int x; //非静态变量
- public static int y; //静态变量
- void method() //非静态方法
- {
- x = 1; //正确,非静态方法可以访问非静态成员
- y = 1; //正确,非静态方法可以访问静态成员
- System.out.println("实例方法访问:x="+x+" y="+y);
- }
- static void smethod() //静态方法
- {
- //x = 3; 错误,静态方法不能非静态成员
- y = 3; //正确,静态方法可以访问静态成员
- System.out.println("静态方法访问:y="+y);
- }
- public static void main(String[] args)
- {
- Example3 prog3 = new Example3();//生成类的实例
- prog3.method(); //非静态方法通过实例来调用
- Example3.smethod(); //静态方法通过类名来调用
- }
- }
4 类继承的例子
- package Example;
- class mother
- {
- public static String sex;//成员变量
- public void method1()//父类成员方法1
- {
- System.out.println("母亲的方法1!");
- }
- public void method2() //父类成员方法2
- {
- System.out.println("母亲的方法2!");
- }
- }
- class boy extends mother //继承
- {
- public void method2() //改写父类成员方法,Java中方法均为虚方法
- {
- System.out.println("我自己的方法2!");
- }
- }
- public class Example4
- {
- public static void main(String[] args)
- {
- boy boys = new boy();
- boy.sex = "男孩";//静态变量的继承
- System.out.println("继承而来的字段sex的值为:"+boy.sex);
- boys.method1();//来自父类的方法
- boys.method2();//自己改写后的方法
- }
5类的访问修饰符
- package Example;
- class program1
- {
- public int a; //公用成员
- protected int b; //保护成员
- int c; //友好成员
- private int d; //私有成员
- public void method1()
- {
- a = 1; //内部访问公用成员,正确
- b = 1; //内部访问保护成员,正确
- c = 1; //内部访问友好成员,正确
- d = 1; //内部访问私有成员,正确
- System.out.println("a="+a+",b="+b+",c="+c+",d="+d);
- }
- }
- class program2
- {
- public void method2()
- {
- program1 prog1 = new program1();
- prog1.a = 2;
- //prog1.b=2 //错误,只能在类的内部访问或在它的继承类里访问
- prog1.c=2; // 正确,在同一个程序集里都可以访问
- //prog1.d = 2; //错误,只能在它的类的内部访问
- System.out.println("另一个类中访问公有成员a="+prog1.a+",友好成员c="+prog1.c);
- }
- }
- class program3 extends program1
- {
- public void method3()
- {
- b = 4; //正确,保护成员可以在它的继承类里访问
- System.out.println("子类可以访问受保护成员b="+b);
- }
- }
- public class Example5
- {
- public static void main(String[] args)
- {
- program1 prog1 = new program1();
- prog1.method1();
- program2 prog2 = new program2();
- prog2.method2();
- program3 prog3 = new program3();
- prog3.method3();
- }
- }
6抽象类及其实现示例
- package Example;
- //应该注意的是:继承抽象类的类,要求抽象类中的抽象方法要被实例化
- abstract class personClass //抽象类
- {
- public String sex;//变量。
- public abstract void method(); //抽象方法。
- }
- class man extends personClass //以抽象类为模块的类
- {
- public void method()//抽象方法的实例化
- {
- System.out.println("继承抽象类的方法被实现化了");
- }
- }
- public class Example6
- {
- public static void main(String[] args)
- {
- man boys = new man();//产生一个对象
- boys.sex = "male";//给对象一个初值
- System.out.println(boys.sex);
- boys.method();//调用man类中的方法
- }
- }
7接口及其实现
- package Example;
- interface Iinterface //定义一个接口
- {
- int i=10; //定义的变量为fianal类型;
- void method(); // 声明接口方法,但不能有方法体{}
- }
- public class Example7 implements Iinterface //实现接口
- {
- public void method() //接口的方法在此必须被重写,注意访问修饰符为public
- {
- System.out.println("接口实现成功!!!");
- }
- public static void main(String[] args)
- {
- Example7 prog7 = new Example7();
- //prog7.i=10; 不能修改i的值,为final类型
- prog7.method();
- }
- }
8 抽象类与接口混合编程例子
- package Example;
- interface myInterface //定义一个接口
- {
- void method1();
- }
- abstract class abstractClass//定义一个抽象类
- {
- public abstract void method2(); //加abstract
- }
- class shixianlei extends abstractClass implements myInterface //继承抽象类,实现接口。
- {
- public String st; //定义自己的字段
- public void method1() //实现接口,注意访问修饰符加public
- {
- System.out.println("接口方法已加public实现");
- }
- public void method2()//实现抽象方法
- {
- System.out.println("抽象类方法已实现");
- }
- }
- public class Example8
- {
- public static void main(String[] args)
- {
- shixianlei sxl = new shixianlei();
- sxl.st = "实现类的字段";
- System.out.println(sxl.st);
- sxl.method1();//实现的接口方法调用
- sxl.method2();//实现的抽象类的方法调用
- }
- }
9 接口回调与多态性
- package Example;
- interface Eat //定义一个接口
- {
- void eat();
- }
- class Cow implements Eat //实现接口。
- {
- public String name="牛哞哞"; //定义自己的字段
- public void eat() //实现接口,注意访问修饰符加public
- {
- System.out.println("母牛爱吃青草");
- }
- }
- class Hen implements Eat //实现接口。
- {
- public String name="鸡咯咯"; //定义自己的字段
- public void eat() //实现接口,注意访问修饰符加public
- {
- System.out.println("母鸡爱吃小虫");
- }
- }
- public class Example9
- {
- public static void main(String[] args)
- {
- //多态的实现,animalEat代表不同对象,表现出不同的行为
- Eat animalEat = new Cow(); //注意这种生成实例的方法,此处代表母牛
- animalEat.eat(); //调用母牛的方法
- //System.out.println(animalEat.name); //不能访问
- animalEat=new Hen(); //注意这种生成实例的方法,此处代表母鸡
- animalEat.eat(); //调用母鸡的方法
- //System.out.println(animalEat.name);//不能访问
- }
- }