1.hello world 程序
public class FirstDemo {
public static void main(String[] args){
System.out.println("Hello World!");
}
}
2.类的基本组成示例
public class TwoDemo {
public static void main(String[] args){
Person p=new Person(); //调用类的无参构造函数
p.age=20; //给对象的公有字段直接赋值
p.setName("zhang shan"); //必须使用公共方法才能给对象的属性赋值
System.out.println("第一个人信息,姓名:"+p.getName()+"年龄:"+p.age);
p.eat(); //调用对象的无参方法
Person p2=new Person(18,"li can"); //调用类的有参构造函数
System.out.println("第二个人信息,姓名:"+p2.getName()+"年龄:"+p2.age);
p2.eat("馒头"); //调用对象的有参方法
}
}
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){
System.out.println("Person can eat"+s); //定义带参数的eat方法,实现方法重载
}
public Person(){ //定义无参构造函数,注意无返回值定义,方法与类同名
}
public Person(int age,String name){//重写一个带参数构造函数,注意无返回值定义,方法与类同名
this.age=age;//前一个age为对象的字段,由this指定,后一个age为函数形参
this.name=name; //前一个name为对象的属性,由this指定,因为在本类中可直接访问,后一个name为函数形参
}
}
3.静态与非静态变量及方法的使用
public class ThreeDemo {
public int x; //非静态变量
public static int y; //静态变量
void method(){//非静态方法
x=1;//正确,非静态方法可以访问非静态成员
y=2; //正确,非静态方法可以访问静态成员
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){
ThreeDemo t=new ThreeDemo();//生成类的实例
t.method();//非静态方法通过实例来调用
ThreeDemo.smethod();//静态方法通过类名来调用
}
}
4.类继承的例子
public class FourDemo {
public static void main(String[] args){
boy b=new boy();
boy.sex="man";//静态变量的继承
System.out.println("继承而来的字段sex的值为:"+boy.sex);
b.method1();//来自父类的方法
b.method2();//自己改写后的方法
mother m=new mother();
m.method2();//来自父类的方法
}
}
class mother{
public static String sex;
public void method1(){
System.out.println("母亲的方法1!");
}
public void method2(){
System.out.println("母亲的方法2!");
}
}
class boy extends mother{
public void method2(){
System.out.println("我自己的方法2!");
}
}
5.类的访问修饰符
public class FiveDemo {
public static void main(String[] args){
program1 p1=new program1();
p1.method1();
program2 p2=new program2();
p2.method2();
program3 p3=new program3();
p3.method1();
p3.method3();
}
}
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 p1=new program1();
p1.a=2;
p1.b=2;//正确
p1.c=2; // 正确,在同一个程序集里都可以访问
// p1.d=2; //错误,只能在它的类的内部访问
System.out.println("a="+p1.a+"b="+p1.b+"c="+p1.c);
}
}
class program3 extends program1{
public void method3(){
program2 p2=new program2();
p2.method2();
b=4; //正确,保护成员可以在它的继承类里访问
System.out.println("子类可以访问受保护成员b="+b);
}
}
6.抽象类及其实现示例
public class SixDemo {
public static void main(String[] args){
man m=new man();
m.sex="man";
System.out.println(m.sex);
m.method();//调用man类中的方法
}
}
//应该注意的是:继承抽象类的类,要求抽象类中的抽象方法要被实例化
abstract class personClass{//抽象类
public String sex;//变量。
public abstract void method(); //抽象方法。但不能有方法体{}
}
class man extends personClass{ //继承抽象类
public void method(){//抽象方法的实例化
System.out.println("继承抽象类的方法被实例化了");
}
}
7.接口及其实现
public class SevenDemo implements Interface{//实现接口
int a=12;
public void method(){//接口的方法在此必须被重写,注意访问修饰符为public
System.out.println("接口实现成功!!!");
}
public static void main(String[] args){
SevenDemo sd=new SevenDemo();
System.out.println(sd.a);//只能访问SevenDemo类下的成员变量
sd.method();
}
}
interface Interface{//定义一个接口
int a=10;
final int b=11; //定义的变量为fianal类型;
void method();// 声明接口方法,但不能有方法体{}
}
8.抽象类与接口混合编程例子
interface Myinterface{//定义一个接口
void method1();
}
abstract class abstractClass{//定义一个抽象类
abstract void method2();//加abstract
}
class shixianlei extends abstractClass implements Myinterface{//继承抽象类,实现接口。
public String s; //定义自己的字段
public void method1(){ //实现接口,注意访问修饰符加public
System.out.println("接口方法已加public实现");
}
void method2(){//实现抽象方法
System.out.println("抽象类方法已实现");
}
}
public class EightDemo {
public static void main(String[] args){
shixianlei sxl=new shixianlei();
sxl.s="实现类的字段";
System.out.println(sxl.s);
sxl.method1();
sxl.method2();
}
}
9.接口回调与多态性
interface Eat{//定义一个接口
void eat();
}
class Cow implements Eat{//实现接口。
String name="牛哞哞"; //定义自己的字段
public void eat(){//实现接口,注意访问修饰符加public
System.out.println("母牛爱吃青草");
}
}
class Hen implements Eat{//实现接口。
String name="鸡咯咯"; //定义自己的字段
public void eat(){//实现接口,注意访问修饰符加public
System.out.println("母鸡爱吃小虫");
}
}
public class NineDemo {
public static void main(String[] args){
//多态的实现,t代表不同对象,表现出不同的行为
Eat t=new Cow(); //注意这种生成实例的方法,此处代表母牛
t.eat(); //调用母牛的方法
//System.out.println(t.name); //不能访问
t=new Hen(); //注意这种生成实例的方法,此处代表母鸡
t.eat(); //调用母鸡的方法
//System.out.println(t.name);//不能访问
}
}