Java自学开工第四周

第九章：关键字

1.this关键字：指的是访问类中的成员变量，用来区分成员变量和局部变量（重名问题）

class Person{
	private String name;
	private int age;
	private String gender;
	Person(){}
	Person(String name,int age,String gender){
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	public void setName(String name){
		name = name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		age = age;
	}
	public int getAge(){
		return age;
	}
	public void setGender(String gender){
		gender = gender;
	}
	public String getGender(){
		return gender;
	}

2.void关键字：

数据类型    type    包装类
基本类型    byte    java.lang.Byte
基本类型    short    java.lang.Short
基本类型    int    java.lang.Integer
基本类型    long    java.lang.Long
基本类型    float    java.lang.Float
基本类型    double    java.lang.Double
基本类型    char    java.lang.Character
基本类型    boolean    java.lang.Boolean

3.权限修饰符
public：任何地方都可以访问
private：只能在类的内部访问
protected：只能在同包内访问，或者不同包的子类。
default（默认的）：同包可以访问。

public class People {
    private int a = 10;
    int b = 20;
    protected int c = 30;
    public int d = 40;
    private void fun1(){
 
    }
 
    void fun2(){
 
    }
 
    protected void fun3(){
 
    }
 
    public void fun4(){
 
    }
 
    public static void main(String[] args) {

        People p = new People();
        System.out.println(p.a);
        p.fun1();
    }

4.static:
1.修饰属性
修饰属性，属性就是静态属性，即属性直属于类，不需要依赖于对象。
静态属性的使用
1.类名.静态属性。
2.对象.静态属性。
没有被static修饰的属性：实例属性、对象属性，必须依赖于对象。

2.修饰方法
当使用static修饰方法，方法即为静态方法，即方法直属于类，不依赖对象
与静态属性使用方法一致。
1.类名.静态方法
静态方法只能直接使用当前类的静态属性
静态方法只能直接调用当前类的静态方法

public class Book {
    public void info() { 
        String name = "英语"; //局部变量
        System.out.println(name);
    }
 
    public static void me(){
        String name = "数学";
        System.out.println(name);
    }
    public static void main(String[] args) {
        Book book = new Book();
        book.info(); //非静态方法调用  对象名.方法()
 
        Book.me(); //静态方法调用 类名.方法()
    }
}

第十章：接口与实现

Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

就像一个类一样，一个接口也能够拥有方法和属性，但是在接口中声明的方法默认是抽象的。（即只有方法标识符，而没有方法体）。

声明：定义接口包含接口声明和接口体，和类不同的是，定义接口时使用关键字interface来声明自己是一个接口，格式如下：

interface 接口的名字

接口体：

interface Printbable{
	public static final int MAX = 100;			//等价写法：int MAX = 100;
	public abstract void add();		//等价写法：void add();
	public abstract float sum(float x,float y);
}

用法：精简程序结构，免除重复定义

比如，有两个及上的的类拥有相同的方法，但是实现功能不一样，就可以定义一个接口，将这个方法提炼出来，在需要使用该方法的类中去实现，就免除了多个类定义系统方法的麻烦。

举例：鸟类和昆虫类都具有飞行的功能，这个功能是相同的，但是其它功能是不同的，在程序实现的过程中，就可以定义一个接口，专门描述飞行。

interface   Flyanimal{   
   void fly();
}
class   Insect {   
   int  legnum=6;
}
class  Bird {   
  int  legnum=2;
  void egg(){};
}
class Ant extendsInsect implements  Flyanimal {
   public void fly(){
       System.out.println("Ant can  fly");
   }
}
classPigeon  extends Bird implements  Flyanimal {
   public void fly(){
       System.out.println("pigeon  can fly");
   }
   public void egg(){
       System.out.println("pigeon  can lay  eggs ");
   }
}
public classInterfaceDemo{
   public static void main(String args[]){
     Ant a=new Ant();
     a.fly();
     System.out.println("Ant's legs are"+ a.legnum);
     Pigeon p= new Pigeon();
    p.fly();
     p.egg();
  }
}

/*
Ant can  fly
Ant'slegs  are 6
pigeon  can fly
pigeon  can lay  eggs
*/

假设一个学校接待方面的程序，招待不同身份的人的食宿问题，其对应规则如下：

理论上，当然可以对每个不同身份的人各定义一个对应的类，并实现各自的方法，但是观察这写类，可以归纳出其有一个共同的模板，即“人”的“食、宿”问题

interfacePerson{
    void eat();
    void sleep();
}
 
class Studentimplements Person{
    public void eat(){
       System.out.println("学生去食堂吃饭！");
    }
    public void sleep(){
       System.out.println("学生回寝室睡觉！");
    }
}
 
class Teacherimplements Person{
    public void eat(){
       System.out.println("教师去教工餐厅吃饭！");
    }
    public void sleep(){
       System.out.println("教师回学校公寓睡觉！");
    }
}
 class Parents implements Person{
    publicvoid eat(){
       System.out.println("家长去招待所饭馆吃饭！");
    }
    public void sleep(){
       System.out.println("家长回招待所睡觉！");
    }
}
 
public class PersonInterface{
         public static void main(String[] args)
         {
                   Person p=new Student();
                   p.eat();
                   p.sleep();
                   p=new Teacher();
                   p.eat();
                   p.sleep();
                   p=new Parents();
                   p.eat();
                   p.sleep();
         }
}
/*
学生去食堂吃饭！
学生回寝室睡觉！
教师去教工餐厅吃饭！
教师回学校公寓睡觉！
家长去招待所饭馆吃饭！
家长回招待所睡觉！
*/