java基础学习日志08

修饰符

/**
* 这个类是描述java的class语法的
* 
* @author jh 修饰类的权限修饰符只能有public和default
* 一个java源文件里面只能有一个用public修饰的类，且和文件名一直的类才能声明为public 用
* abstract修饰的类是抽象类，抽象类不能被实例化 一个类如果要继承一个抽象类，就必须实现抽象类里面的抽象方法。
* 用final修饰的类：不能再被扩展，不包含子类的类；易于安全性的实现，或用于创建固定功能的类 用final修饰的类不能被继承，
*/
public class Animal {
/*
* 四个权限修饰符都可以修饰成员变量 public：可被所有类引用 protected：该类自身、子类、同一包中的其他类
* 缺省(没有访问控制符)：该类自身、本包中的类 private：仅可被该类自身引用和修改，不能被其他任何类(包括子类)引用
* 
* 
*/

public String name;
String type;
protected int age;
private String sex;
/*
* 用static修饰的成员变量，在类加载时已经分配好内存，在静态方法区，所有该类的对象共用这个内存，
* 所以，如果该成员变量修饰为static就表示该类的该成员变量对该类的所有对象是共享的内存， 也就是说，该类所有对象该属性值都是相同的。
* static：类成员变量，对所有的实例一致，引用是前缀可使用类名或对象名 为什么用static修饰的变量可以通过类名来调用呢？
* 用static修饰的成员变量，在类加载时已经分配好内存.
*/
public static double length;
/*
* 用final修饰的成员变量，在定义时可以最好给设定初始值，如果没有给初始值，则需要在构造函数中给该成员变量赋值。
*/
public final int eyeNumber = 2;

// public Animal() {
// // TODO Auto-generated constructor stub
// eyeNumber=2;
// }
/**
* 这个方法是用来解释方法的参数的 run(String name,int num)里面String,int分别是name,num类型，
* name,num是run方法的形参 实参：在调用方法时，给方法传递的值叫实参
* 
* @param name
* @param num
*/
public void run(String name, int num) {
System.out.println(name + "跑了" + num + "米");
}
/**
* 吃苹果方法
* @param ap	代表苹果对象
* Apple 代表参数类型，是一个Class
*/
public void eat(Apple ap) {
System.out.println("吃了一个"+ap.name);
}
/**
* 
* @param ap
* @param number
* @return
* 在方法中，返回值的类型一定要和定义时的类型保持一致，
* 比如public String eat(Apple ap,int number)定义时返回值类型是String
* 所以在retrun 后面的值一定要是String类型的
* 如果该方法有返回值，则在调用时最好用一个和返回值类型一样的变量来去接受该返回值
*/
public String eat(Apple ap,int number){
String str = "没吃饱";
if(number>5){
str = "吃饱了";
}
return str;
}
/**
* 方法的返回值可以是基本数据类型，也可以是引用类型
* 比如bornSamAnimal()方法，他的返回值就是一个Animal的对象
* 那么在接受该方法的返回的值的时候就要用和该方法的返回值类型一样的变量接受
* @return
*/
public Animal bornSamAnimal(){
Animal samAn = new Animal();
samAn.name="jerry";
samAn.age=1;
samAn.sex="雄";
return samAn;
}
/*
* 权限修饰符修饰方法和修饰变量一样
* */
/**
* protected修饰的方法，只能在本类中，本包中的其他类，以及其他包中的子类访问，
* （在其他包中，只能通过该类的子类进行访问，不能有该类对象访问）
*/
protected void run1() {
System.out.println("aaa");
}
/**
* 如果没有写权限修饰符，则默认为default
* 默认的权限修饰符，只能由本包中的其他类，以及本类访问，不允许其他包中的子类访问
*/
void run2(){

}
/**
* 用private修饰的类只能在该类中由该类本身访问，不能被其他类进行访问包括子类
*/
private void run3(){

}
/**
* 用static 修饰的方法叫做静态方法，也叫做类方法，可以直接通过类名来调用，也可以通过对象名来调用
* Animal.sleep("小郑");
an.sleep(an.name);
* @param name
*/
public static void sleep(String name){
System.out.println(name+"在睡觉");
}

/**
* 在父类中用final修饰的方法，子类不能重写，
* 
*/
public final void eat(){

}
/**
* 用abstract修饰的方法叫做抽象方法，抽象方法只有方法的声明，没有方法的实现。
* 一个类中如有有一个抽象方法，则该类必须是抽象类
*/
//	public abstract void study();
public static void main(String[] args) {
Animal an = new Animal();
// 其中run方法里面的值“tom”，100是run方法的实参
// 在给方法传递实参，实参的类型要和方法定义时的形参类型保持一致，如果不一致就会报错
an.name="tom";
an.run("tom", 100);
Animal an1 = new Animal();
Apple a = new Apple();
a.name="红富士";
String str = an.eat(a,10);
System.out.println(str);
Animal sm = an.bornSamAnimal();
System.out.println(sm.name);
System.out.println(sm.age);
System.out.println(sm.sex);
/*
* 用static 修饰的方法叫做静态方法，也叫做类方法，可以直接通过类名来调用，也可以通过对象名来调用
* */
Animal.sleep("小郑");
an.sleep(an.name);

}


}

/**
* 用默认的权限修饰符表示该类只能被当前包中的其他类访问
* 
* @author jh
*
*/
class Dog extends Animal {
/**
* 在父类中已有的方法，子类里面重新定义该方法，这种叫做方法的重写（Override）
* 在方法的重写中，子类方法要和父类方法拥有相同方法名，参数类型，返回值类型
* 并且子类重写的方法不能比父类方法有着更加严格的访问权限
* 
*/
@Override
public void eat(Apple ap) {
System.out.println("吃了一个"+ap.name);
}

//	public void eat(){
//	
//	}
public void run() {
// TODO Auto-generated method stub
Dog d = new Dog();
d.run2();

}
}

class Apple {
String name;
}