JAVA笔记（8）面向对象（下）

第1章final和static关键字

1.1final关键字的概述及特点

•final关键字是最终的意思，可以修饰类，成员变量，成员方法。
–修饰类，则该类是最终类，类不能被继承，不能有子类
–修饰变量，变量就变成了常量，只能被赋值一次
–修饰方法，方法不能被重写

1.1.1案例代码一

package javalearning;
/*
public final class Father {

}
*/

public class Father {
	public final void method() {
		System.out.println("method father");
	}
}

package javalearning;

public class Son extends Father {
	public final int age = 20;
	
	public void show() {
		//age = 10;//age被final修饰以后就不可以再赋值了。若没有被final修饰，则后面调用show方法时结果为10
		System.out.println(age);
	}
	
	/*
	@Override//子类重写父类方法//但是final修饰方法后，方法不能重写，因此要注释掉
	public void method() {
		System.out.println("method son");
	}
	*/
}

package javalearning;
/*
 * final：是一个关键字，表示最终的意思。可以用来修饰类，修饰变量，修饰方法。
 * 修饰类：表明该类是最终类，不能被继承
 * 修饰变量：表明该变量是常量，不能再次被赋值
 * 修饰方法：表明该方法是最终方法，不能被重写
 */
public class FinalDemo {
	public static void main(String[] args) {
		Son s = new Son();
		s.show();
	}
}

1.2static关键字的概述及特点

1.2.1静态的概述

当在定义类的时候，类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。当在调用对象的某个方法时，这个方法没有访问到对象的特有数据时，方法创建这个对象有些多余。可是不创建对象，方法又调用不了，这时就会想，那么我们能不能不创建对象，就可以调用方法呢？
可以的，我们可以通过static关键字来实现。static它是静态修饰符，一般用来修饰类中的成员。可以用来修饰成员变量和成员方法。

1.2.2静态的特点

–被类的所有对象共享
•这也是我们判断是否使用静态关键字的条件，如果成员被所有对象共享（值都相同），则可以使用static
–可以通过类名或者接口名调用，不需要通过对象调用，如：不需要用s1.graduateFrom = "xx大学"来调用(可以实现但没必要)。可以这样调用：Student.graduateFrom = “xx大学”;
–优先于对象存在。如：创建对象s1之前就可以使用类名调用被static修饰的成员变量（方法）了。
–随着类的加载而加载。

如果一个类中所有属性和方法都是静态的，则要把它的的构造器私有化

1.2.3案例代码二

package javalearning_01;

public class Student {
	public String name;
	public int age;
	//public String graduateFrom; //毕业院校，当毕业院校的值都是相同的，为了不用每个对象都分别写出毕业院校，我们用static关键字来实现共享
	public static String graduateFrom; //毕业院校
	
	public void show() {
		System.out.println(name+"---"+age+"---"+graduateFrom);
	}
}

package javalearning_01;
/*
 * static：是一个关键字，静态的意思。可以用来修饰成员变量和成员方法。
 * static修饰成员的特点：
 * 		A:被类的所有对象共享。
 * 			其实也是判断一个成员是否应该用static修饰的条件。
 * 		B:可以通过类名直接访问
 * 		C:优先于对象存在
 * 		D:随着类的加载而加载
 */
public class StaticDemo {
	public static void main(String[] args) {
		Student.graduateFrom = "xx大学";
		
		Student s1 = new Student();
		s1.name = "林青霞";
		s1.age = 30;
		//s1.graduateFrom = "xx大学";
		s1.show();
		System.out.println("----------------------");
		
		Student s2 = new Student();
		s2.name = "刘德华";
		s2.age = 28;
		//s2.graduateFrom = "xx大学";
		s2.show();
	}
}
/*out
林青霞---30---xx大学
----------------------
刘德华---28---xx大学
删除Student.graduateFrom = "xx大学";恢复s1.graduateFrom = "xx大学";也可以得到相同结果，只是不建议。
若没有使用static，只有s1.graduateFrom = "xx大学";没有s2.graduateFrom = "xx大学";的话，结果为：
林青霞---30---xx大学
----------------------
刘德华---28---null
*/

1.3static方法的访问特点及注意事项

•静态方法的访问特点
–静态方法只能访问静态的成员变量和静态的成员方法
–静态方法的注意事项
–在静态方法中是没有this,super关键字的
•静态的内容是随着类的加载而加载，this和super是随着对象的创建而存在。

1.3.1案例代码三

package javalearning_02;
/*
 * 非静态的成员方法：
 * 		能访问静态的成员变量
 * 		能访问非静态的成员变量
 * 		能访问静态的成员方法
 * 		能访问非静态的成员方法
 * 
 * 静态的成员方法：
 * 		能访问静态的成员变量
 * 		能访问静态的成员方法
 * 
 * 注意事项：
 * 		静态成员方法中不能出现this,super这样的关键字。
 * 		原因是：静态是随着类的加载而加载，this,super这样的关键字是随着对象的创建而存在。类加载的时候可能对象还没创建呢
 *      如上一个代码中"创建对象s1之前就可以使用类名调用被static修饰的成员变量（方法）了。"
 * 			  静态方法是优先于对象进内存的，先进内存的，不能访问后进内存的。
 */
public class Student {
	//非静态的成员变量
	private String name = "林青霞";//private修饰后在本类中是可以访问的
	//静态的成员变量
	private static int age = 30;
	
	//非静态的成员方法
	public void show() {
		this.name = "刘德华";
		System.out.println(name);//输出刘德华
		System.out.println(age);
		show2();
		show4();
	}
	
	public void show2() {}
	
	//静态的成员方法
	public static void show3() {
		//this.age
		//this.name//都报错，静态成员方法中不能出现this,super这样的关键字。
		
		//System.out.println(name);//不能访问非静态的成员变量
		System.out.println(age);
		//show2();//不能访问非静态的成员方法
		show4();
	}
	
	public static void show4() {}
}

第2章抽象类

2.1抽象类概述

当编写一个类时，我们往往会为该类定义一些方法，这些方法是用来描述该类的功能的，回想前面我们的猫狗案例，提取出了一个动物类，这个时候我们是可以通过Animal a = new Animal()来创建动物对象的，其实这是不对的。为什么呢?因为，我说动物，你知道我说的是什么动物吗?只有看到了具体的动物，你才知道，这是什么动物。 所以说，动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。同理，我们也可以推想，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。

相当于：多态中成员方法编译看父类运行看子类，有些方法如“吃东西”，子类中可以明确吃啥，父类中的“吃东西”就多此一举，几乎用不到，于是就干脆不写“吃东西”这个方法体了，就出现了抽象方法，有抽象方法的类就必须是一个抽象类。

2.1.1案例代码四

package javalearning_01;

public abstract class Animal {//因为含有抽象方法，所以这个类必须也是抽象类
//将来子类继承Animal的时候就会继承eat（下段代码被注释掉的部分），a.eat()会输出“吃东西”.
//但这毫无意义，因为每个动物吃的是不一样的东西，所以这里的eat方法应该设置为没有方法体的抽象方法才合理。
	/*
	public void eat() {
		System.out.println("吃东西");
	}
	*/
	
	
	
	//抽象方法
	public abstract void eat();//注意这里没有花括号{}，因为没有方法体。但是有分号。而无参构造法虽然写在同一行，但是有方法体，自然没有分号
}

package javalearning_01;

public class AnimalDemo {
	public static void main(String[] args) {
		/*
		Animal a = new Animal();//因为Animal已经是抽象的类了，所以不可以这样创建对象了。会报错Cannot instantiate the type Animal不能实例化
		a.eat();
		*/
	}
}

2.2抽象类的特点

抽象类和抽象方法必须用abstract关键字修饰
格式:
public abstract class 类名 {}
public abstract void eat();
抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
抽象类不能实例化
那么，抽象类如何实例化呢?
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
抽象类的子类，要么本身是抽象类（自动继承了父类的抽象方法）可以不重写父类抽象方法；要么本身不是抽象类，因此这种子类中不能有抽象方法，但它又继承了抽象类，也继承了抽象类中的抽象方法，为了没有抽象方法就重写抽象父类中的所有抽象方法（被重写的方法在父类中是抽象的，在子类中不是抽象的。详见代码）

2.2.1案例代码五

package javalearning_02;
//抽象类
public abstract class Animal {
	//抽象方法
	public abstract void eat();//注意没有{}
	
	public void sleep() {
		System.out.println("睡觉");
	}
}

package javalearning_02;

public class Cat extends Animal {//不写下面的东西就会报错The type Cat must implement the inherited abstract method Animal.eat()
//要求继承（重写）抽象类animal中的抽象方法eat，可以用鼠标点击报错的图案，然后点击“add unimplemented methods”即可自动生成。

	@Override//重写父类的eat方法，在父类中eat是抽象的，在此不是抽象方法
	public void eat() {
		System.out.println("猫吃鱼");
	}

}

package javalearning_02;

public abstract class Dog extends Animal {
	//dog中没有重写父类的抽象方法，说明它继承了父类原有的抽象方法，它有抽象方法，因此dog也必须是抽象类。所以要加上abstract。
}

package javalearning_02;
/*
 * 抽象类的特点：
 * 		A:抽象类和抽象方法必须使用abstract关键字修饰
 * 		B:抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
 * 		C:抽象类不能实例化(不能new该类 )
 * 			抽象类如何实例化呢?
 * 			参照多态的方式，通过子类对象实例化。
 * 		D:抽象类的子类
 * 			要么本身是抽象类（继承了父类的抽象方法）
 *     			要么重写抽象父类中的所有抽象方法（自己可以不是抽象类，被重写的方在父类中是抽象的，在子类中不是抽象的。详见代码）
 * 
 */
public class AnimalDemo {
	public static void main(String[] args) {
		//创建对象
		//Animal a = new Animal();//抽象类Animal不可以这样实例化
		//按照多态的形式实例化抽象类
		Animal a = new Cat();
		a.eat();//编译看左边，运行看右边
		a.sleep();//编译看左边，运行看右边，虽然cat中没有sleep，但是父类中有，被继承了。
	}
}

/*out
猫吃鱼
睡觉
*/

2.3抽象类的成员的特点

•成员变量
–可以是变量
–也可以是常量（用final修饰的变量）
•构造方法
–有构造方法，但是不能实例化
–那么，构造方法的作用是什么呢?
•用于子类访问父类数据的初始化
•成员方法
–可以有抽象方法，用来限定子类必须完成某些动作
–也可以有非抽象方法，用来提高代码复用性

2.3.1案例代码六

package javalearning_03;

public abstract class Person {
	private int age = 20;
	private final String country = "中国";
	
	public Person() {}
	
	public Person(int age) {
		this.age = age;
	}
	
	public void show() {
		age = 30;
		System.out.println(age);
		//country = "美国";//报错，因为country被final修饰，只可以赋值一次，是常量了。
		System.out.println(country);
	}
	
	public abstract void eat();
}

package javalearning_03;

public class Student extends Person {

	@Override//重写父类的抽象方法。
	public void eat() {
		System.out.println("学生吃米饭");
	}
	
}

package javalearning_03;
/*
 * 抽象类的成员特点：
 * 		成员变量：
 * 			有成员变量，成员变量可以是变量，也可以是常量（用final修饰的变量）。
 * 		构造方法：
 * 			有构造方法。
 * 			抽象类中构造方法的作用?
 * 				用于子类访问父类数据的初始化。
 * 		成员方法：
 * 			有成员方法，成员方法可以是抽象的，也可以是非抽象的。
 * 			抽象方法：用来限定子类必须完成某些动作
 * 			非抽象方法：用来提高代码的复用性
 */
public class PersonDemo {
	public static void main(String[] args) {
		Person p = new Student();
		p.show();
	}
}

2.4抽象类的练习之老师案例

•老师案例
–具体事物：基础班老师，高级班老师
–共性：姓名，年龄，讲课。

2.4.1案例代码七

package yyTest2;

public abstract class Teacher {
	//成员变量
	private String name;
	private int age;
	//构造方法，无参、带参
	public Teacher () {}
	
	public Teacher(String name ,int age) {
		this.name=name;
		this.age=age;				
	}
	//成员方法
	public void setName(String name) {
		this.name = name;
	}
	
	public String getName() {
		return name;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
	
	public int getAge() {
		return age;
	}
	
	//抽象方法
	public abstract void teach();

}

package yyTest2;
//基础班老师
public class BasicTeacher extends Teacher{
	//无参构造方法
	public BasicTeacher () {}	
	
	//带参构造方法
	public BasicTeacher(String name , int age) {
		super(name,age);//调用父类带参构造方法
	}
	
	
	
	@Override//重写父类中的抽象方法，但重写时不是抽象方法，只是普通方法
	public void teach() {
		System.out.println("基础班老师讲解必修课");
	}

}

package yyTest2;
//高级班老师
public class AdvancedTeacher extends Teacher{
	//无参构造法
	public AdvancedTeacher() {}
	
	//带参构造方法
	public AdvancedTeacher(String name ,int age) {
		super(name,age);//调用父类带参构造方法
	}
	
	@Override//重写父类中的抽象方法，但重写时不是抽象方法，只是普通方法
	public void teach() {
		System.out.println("高级班老师讲解选修课");
	}

}

package yyTest2;
/*
 * 分析：从具体到抽象
 * 实现：从抽象到具体
 * 使用：使用的是具体的类的对象
 * 
 * 分析：
 * package javalearning_04;
/*
 * 分析：从具体到抽象
 * 实现：从抽象到具体
 * 使用：使用的是具体的类的对象
 * 
 * 分析：
 * 		基础班老师：
 * 			成员变量：name,age
 * 			构造方法：无参，带参
 * 			成员方法：getXxx(),setXxx(),teach(){}
 * 		高级班老师：
 * 			成员变量：name,age
 * 			构造方法：无参，带参
 * 			成员方法：getXxx(),setXxx(),teach(){}
 * 
 * 		抽象的老师类：(观察上面的两种老师，除了teach的内容不同，其他都一样，因此只让teach作为抽象方法)
 * 			成员变量：name,age
 * 			构造方法：无参，带参
 * 			成员方法：getXxx(),setXxx(),teach();这里的teach没有{}，表示没有方法体，是抽象的方法。
 * 
 */
public class TeacherDemo {
	public static void main(String[] args) {
		//使用的是具体的类的对象
		//简单测试
		/*有问题
		BasicTeacher bt = new BasicTeacher();
		bt.name = "aa";//先开始报错Syntax error on token "name", VariableDeclaratorId expected after this token，因为忘写main方法了。
		//写了main以后仍然错误，是因为name是私有变量，要么用setXxx赋值，要么用构造方法赋值
		 */
		
		/*没问题
		BasicTeacher bt = new BasicTeacher("张三",35);
		bt.teach();//基础班老师讲解必修课
		System.out.println("基础班老师信息："+bt.getName()+bt.getAge());//基础班老师信息：张三35
		*/
		 
		
		//多态形式的测试
		Teacher t = new BasicTeacher();//无参构造，然后使用setXxx赋值
		t.setName("李四");
		t.setAge(38);
		System.out.println("基础班老师信息："+t.getName()+t.getAge());//基础班老师信息：李四38
		t.teach();基础班老师讲解必修课
		System.out.println("-------------");
	
			
		t = new BasicTeacher("张三",35);//使用带参构造法赋值
		System.out.println("基础班老师信息："+t.getName()+t.getAge());//基础班老师信息：张三35
		t.teach();基础班老师讲解必修课	
		
	}

}
/*
基础班老师信息：李四38
基础班老师讲解必修课
-------------
基础班老师信息：张三35
基础班老师讲解必修课
*/

第3章接口的概述以及练习

3.1接口的概述

继续回到我们的猫狗案例，我们想想狗一般就是看门，猫一般就是作为宠物了。但是，现在有很多的驯养员或者是驯兽师，可以训练出：猫钻火圈，狗跳高，狗做计算等。而这些额外的动作，并不是所有猫或者狗一开始就具备的，这应该属于经过特殊的培训训练出来的。所以，这些额外的动作定义到动物类中就不合适，也不适合直接定义到猫或者狗中，因为只有部分猫狗具备这些功能。所以，为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现(抽象)，将来哪些猫狗需要被训练，只需要这部分猫狗把这些额外功能实现即可（重写接口中的方法）。

3.2接口的特点

•接口用关键字interface表示
–格式：public interface 接口名 {}
–类实现接口用implements表示
•格式：public class 类名 implements 接口名 {}
–接口不能实例化
•那么，接口如何实例化呢?
•按照多态的方式，由具体的实现类实例化。其实这也是多态的一种，接口多态。
–接口的实现类
•要么是抽象类，要么不是抽象类即重写接口中的所有抽象方法(推荐)

3.2.1案例代码八

package javalearning_01;
/*
 * 接口的特点：
 * 		A:定义接口使用的是interface关键字
 * 		B:类和接口之间是实现关系，用implements关键字表示
 * 		C:接口不能实例化
 * 			接口有没有其他的方式实例化呢?
 * 			参照多态的形式使用实现类来实例化。
 * 		D:接口的实现类
 * 			要么重写接口中的所有的抽象方法
 * 			要么是一个抽象类
 * 
 * 多态的几种形式：
 * 		具体类多态(几乎不用)
 * 		抽象类多态(常用)
 * 		接口多态(最常用)
 */
public class InterfaceDemo {
	public static void main(String[] args) {
		//Jumpping j = new Jumpping();//接口不能直接实例化
		//接口多态的形式实例化
		Jumpping j = new Cat();
		j.jump();//方法：编译看左边，运行看右边，输出：猫可以跳高了
	}
}

package javalearning_01;

public class Cat implements Jumpping { //类实现接口
	//重写接口中的那个抽象方法
	@Override
	public void jump() {
		System.out.println("猫可以跳高了");
	}

}

package javalearning_01;

public abstract class Dog implements Jumpping {

}

package javalearning_01;
//定义了一个跳高的接口
public interface Jumpping {
	//抽象方法
	public abstract void jump();
}

3.3接口的成员特点

•成员变量
–默认修饰符 public static final，所以只能是静态的常量
•构造方法
–没有，因为接口主要是扩展功能的，而没有具体存在
•成员方法
–默认修饰符：public abstract，所以都是抽象方法。

3.3.1案例代码九

package javalearning_02;
/*
 * 接口的成员特点：
 * 		成员变量：
 * 			有成员变量，默认修饰符：public static final，所以只能是静态的常量	
 * 		构造方法：
 * 			没有构造方法。
 * 		成员方法：
 * 			有成员方法，默认修饰符：public abstract，所以都是抽象方法。
 * 			
 * 
 * Object:是类层次结构的根类，所有的类都直接的或者间接的继承自该类。A类若extends B类，就直接继承B类，若没有extends任何类，就直接默认继承Object类。
 */
public class InterfaceDemo {
	public static void main(String[] args) {
		//按照多态的形式创建接口对象
		Inter i = new InterImpl();
		//i.num = 30;//仍然报错，接口中的变量默认是常量
		//System.out.println(i.num);
		//i.num2 = 40;/报错，因为num2被final修饰了，是常量，只能赋值一次
		//System.out.println(i.num2);
		//把鼠标往num和num2上面一放，会出现The static field Inter.num/num2....表明这两个变量也是静态的
		System.out.println(Inter.num);//静态的变量，可以通过类名或者接口名来访问，10
		System.out.println(Inter.num2);//20
	}
}

package javalearning_02;

//public class InterImpl implements Inter//没有继承的父类，就默认继承Object类，和下面的书写方式是同样的效果
public class InterImpl extends Object implements Inter {
	public InterImpl() {
		super();//默认访问父类的无参构造方法，这里访问的就是Object类的构造方法
	}

	@Override
	public void method() {
		
	}
}

package javalearning_02;

public interface Inter {
	public int num = 10;
	public final int num2 = 20;
	public static final int num3 = 30;//实际上num和num2也是和num3一样的，写与不写都默认有这三个修饰符，因此num和num2也都是静态的常量。
	
	//public Inter() {}//报错，因为接口没有构造方法
	
	//public void show() {}//报错，因为接口中的方法必须是抽象方法，不能有{}
	public abstract void method();
}

3.4类与类_类与接口_接口与接口的关系

•类与类
–继承关系，只能单继承，但是可以多层继承
•类与接口
–实现关系，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口
•接口与接口
–继承关系，可以单继承，也可以多继承

java的类不能多继承，对
java不能多继承，错，因为Java的接口可以多继承

3.4.1案例代码十

package javalearning_03;
/*
 * 类与类：
 * 		继承关系，只能单继承，可以多层继承。
 * 
 * 类与接口：
 * 		实现关系，可以单实现，也可以多实现。
 * 		还可以在继承一个类的同时实现多个接口。
 * 
 * 接口与接口：
 * 		继承关系，可以单继承，也可以多继承。
 */
public class InterfaceDemo {

}

package javalearning_03;

public interface Sister extends Father,Mother {

}

package javalearning_03;

public class Son extends Object implements Father,Mother {

}

package javalearning_03;

public interface Mother {

}

package javalearning_03;

public interface Father {

}

3.5抽象类与接口的区别

• 成员区别
抽象类 变量,常量;有抽象方法，非抽象方法。有构造方法
接口 常量;抽象方法。无构造方法
•关系区别
类与类 继承，单继承，多层继承
类与接口 实现，单实现，多实现
接口与接口 继承，单继承，多继承
•设计理念区别
抽象类 被继承体现的是：”is a”的关系。共性功能
接口 被实现体现的是：”like a”的关系。扩展功能

3.5.1案例代码十

package javalearning_04;
/*
 * 抽象类和接口的区别：
 * 		A:成员区别
 * 			抽象类：
 * 				成员变量：可以是变量，也可以是常量
 * 				构造方法：有
 * 				成员方法：可以是抽象方法，也可以是非抽象方法
 * 			接口：
 * 				成员变量：只能是常量
 * 				成员方法：只能是抽象方法
 * 		B:关系区别
 * 			类与类：继承关系，只能单继承，可以多层继承
 * 			类与接口：实现关系，可以单实现，也可以多实现
 * 			接口与接口：继承关系，可以单继承，也可以多继承
 * 		C:设计理念的区别
 * 			抽象类 被继承体现的是："is a"	抽象类中定义的是继承体系的共性功能
 * 			接口 被实现体现的是："like a"  接口中定义的是该体系的扩展功能
 * 			
 * 			举例：
 * 				猫，动物
 * 				猫，跳高运动员
 */
public class InterfaceDemo {

}

3.6接口的练习

3.6.1接口的练习之猫狗案例

3.6.1.1案例代码十一

package jl02;
//动物类
public abstract class Animal {//因为有抽象方法所以是抽象类
	//成员变量
	private  String name;
	private int age;
	
	//构造方法，无参， 有参
	public Animal() {}//无参构造方法有在{}但是没有分号
	
	public Animal(String name,int age) {
		this.name=name;
		this.age=age;
	}
	
	

	//成员方法
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name=name;
	}
	
	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
	//抽象方法
	public abstract void eat();//抽象方法没有{}但有分号
	

	
}

package jl02;
//跳高接口
public interface Jumpping {
	public abstract void jump();//抽象方法有分号，没有{}

}

package jl02;

public class Cat extends Animal implements Jumpping{
	//构造方法，无参，有参
	public Cat() {}
	
	public Cat(String name,int age) {
		super(name,age);//调用父类的有参构造方法
	}
	
	//重写父类和接口中的抽象方法
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
	@Override
	public void jump() {
		System.out.println("猫会跳高了");
	}
}

package jl02;

public class Dog extends Animal implements Jumpping{
	public Dog() {}
	
	public Dog(String name,int age) {
		super(name,age);
	}
	

	@Override
	public void jump() {
		System.out.println("狗会跳高了");
		
	}

	@Override
	public void eat() {
		System.out.println("狗吃骨头");
	}
	

}

package jl02;

/*
 * 需求：猫狗案例,让所有的猫狗具备跳高的额外功能
 * 
 * 分析：从具体到抽象
 * 		猫：姓名，年龄，吃饭(){}
 * 		狗：姓名，年龄，吃饭(){}
 * 		发现了共性的内容，就提取了一个父类。
 * 		抽象动物类：
 * 			姓名，年龄，吃饭();
 * 		猫：继承动物类
 * 		狗：继承动物类
 * 		
 * 		跳高的额外功能是一个扩展功能，所以应该定义接口实现。
 * 		跳高接口：
 * 			跳高();
 * 		猫：继承动物类,实现跳高接口
 * 		狗：继承动物类,实现跳高接口
 * 实现：从抽象到具体
 * 使用：使用的是具体的类的对象
 * 
 */
public class InterfaceTest {
	public static void main(String[] args) {
		Cat c = new Cat();
		c.setName("加菲猫");
		c.setAge(3);
		System.out.println(c.getName()+"---"+c.getAge());
		c.eat();
		c.jump();
		System.out.println("-------------------------");
		
		Cat c2 = new Cat("加菲猫",3);
		System.out.println(c2.getName()+"---"+c2.getAge());
		c2.eat();
		c2.jump();
	}
}
/*
加菲猫---3
猫吃鱼
猫会跳高了
-------------------------
加菲猫---3
猫吃鱼
猫会跳高了
*/
	

3.6.2接口的练习之运动员和教练案例

3.6.2.1接口的练习之运动员和教练案例分析

3.6.2.2接口的练习之运动员和教练案例的代码实现

3.6.2.2.1案例代码十二

package jl03;

public abstract class Person {
	//成员变量
	private String name;
	private int age;
	
	//构造方法，无参有参
	public Person() {}//无参构造方法没有分号，但是有{}
	
	public Person(String name,int age) {
		this.name=name;
		this.age=age;
	}
	
	//成员方法
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
	//抽象方法
	public abstract void eat();//抽象方法有分号没有{}
	
	

}

package jl03;
//说英语的接口
public interface SpeakEnglish {
	public abstract void speak();//抽象方法没有{}但是有分号
	

}

package jl03;
//抽象的运动员类
public abstract class Player extends Person {
	//构造方法，无参有参
	public Player() {}
	
	public Player(String name,int age) {
		super(name,age);//调用父类的无参构造法
	}
	
	//抽象的学习方法
	public abstract void study();
	
	
	
	

}

package jl03;
//抽象的教练类
public abstract class Coach extends Person  {
	//构造函数，无参有参
	public Coach(){}
	
	public Coach(String name,int age) {
		super(name,age);
	}
	//抽象的教方法
	public abstract void teach();
	
	

}

package jl03;

//乒乓球运动员具体类
public class PingPangPlayer extends Player implements SpeakEnglish {
	// 构造方法，无参有参
	public PingPangPlayer() {
	}

	public PingPangPlayer(String name, int age) {
		super(name, age);
	}

	// 重写父类和接口中的抽象方法(多层继承关系要将所有的父类中的抽象方法都写出来)
	@Override
	public void study() {
		System.out.println("乒乓球运动员学习发球接球");
	}

	@Override
	public void speak() {
		System.out.println("乒乓球运动员说英语");

	}

	@Override
	public void eat() {
		System.out.println("乒乓球运动员吃套餐1");

	}

}

package jl03;
//篮球运动员具体类
public class BasketballPlayer extends Player {
	public BasketballPlayer() {
	}

	public BasketballPlayer(String name, int age) {
		super(name, age);

	}

	@Override
	public void study() {
		System.out.println("篮球运动员学习运球投篮");

	}

	@Override
	public void eat() {
		System.out.println("篮球运动员吃套餐2");

	}

}

package jl03;
//乒乓球教练具体类
public class PingPangCoach extends Coach implements SpeakEnglish{
	public PingPangCoach() {}
	
	public PingPangCoach(String name,int age) {
		super(name,age);
	}
	
	
	@Override
	public void speak() {
		System.out.println("乒乓球教练说英语");
		
	}

	@Override
	public void teach() {
		System.out.println("乒乓球教练教发球接球");
		
	}

	@Override
	public void eat() {
		System.out.println("乒乓球教练吃套餐3");
		
	}
	
	

}

package jl03;
//篮球教练具体类
public class BasketballCoach extends Coach {
	public BasketballCoach(){}
	
	public BasketballCoach(String name,int age){
		super(name,age);
	}
	

	@Override
	public void teach() {
		System.out.println("篮球教练教运球投篮");
		
	}

	@Override
	public void eat() {
		System.out.println("篮球教练吃套餐4");
	}
	

}

3.6.2.3接口的练习之运动员和教练案例的测试

3.6.2.3.1案例代码十三

package jl03;

public class InterfaceTest {
	public static void main(String[] args) {
		// 测试运动员
		// 乒乓球运动员
		PingPangPlayer ppp = new PingPangPlayer();
		ppp.setName("小王");
		ppp.setAge(20);
		System.out.println(ppp.getName() + "---" + ppp.getAge());
		ppp.eat();
		ppp.study();
		ppp.speak();

		// 篮球运动员
		BasketballPlayer bp = new BasketballPlayer("小张", 21);
		System.out.println(bp.getName() + "---" + bp.getAge());
		bp.eat();
		bp.study();

		
		// 测试教练同上
	}

}

/*
小王---20
乒乓球运动员吃套餐1
乒乓球运动员学习发球接球
乒乓球运动员说英语
小张---21
篮球运动员吃套餐2
篮球运动员学习运球投篮
*/

注意：这里在创建对象时，并没有使用父类引用指向子类对象的多态方式，我个人认为，写成多态的方式更好，原因可见：
https://blog.csdn.net/sinat_18882775/article/details/50154491
https://blog.csdn.net/weixin_45564920/article/details/100647620
https://blog.csdn.net/han_yankun2009/article/details/40451981

第4章包的概述和权限修饰符

4.1包的概述和注意事项

4.1.1包的概述

–其实就是文件夹
–作用：对类进行分类管理
–包的划分：
•举例：
–学生类的增加，删除，修改，查询
–老师类的增加，删除，修改，查询
–以及以后可能出现的其他的类的增加，删除，修改，查询
–基本的划分：按照模块和功能分。
–高级的划分：做项目的时候你就能看到了。

4.1.2定义包的格式

–package 包名;
•多级包用.分开即可
–注意事项：
•package语句必须是程序的第一条可执行的代码
•package语句在一个java文件中只能有一个

4.1.3案例代码十四

package javalearning;
//package javalearning2;一个java文件只能有一个包
/*
 * 包：其实就是文件夹。
 * 作用：就是对类进行分类管理。
 * 
 * 举例：
 * 		学生类：增加，删除，修改，查询
 * 		老师类：增加，删除，修改，查询
 * 		...
 * 
 * 		方案1：按照功能分
 * 			javalearning.add（文件夹javalearning里面有一个文件夹叫做add）
 * 				AddStudent
 * 				AddTeacher
 * 			javalearning.delete
 * 				DeleteStudent
 * 				DeleteTeacher
 * 			...
 * 		方案2：按照模块分
 * 			javalearning.student
 * 				AddStudent
 * 				DeleteStudent
 * 				...
 * 			javalearning.teacher
 * 				AddTeacher
 * 				DeleteTeacher
 * 包的定义格式：
 * 		package 包名;
 * 		如果是多级包用.隔开即可
 * 注意事项：
 * 		A:package必须是程序的第一条可执行语句
 * 		B:package语句在一个java文件中只能有一个
 */
public class PackageDemo {

}

4.2导包的格式及使用

4.2.1导包概述

不同包下的类之间的访问，我们发现，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能。

4.2.2导包格式

–import 包名;

4.2.3案例代码十五

package javalearning;
/*
 * 导包：
 * 		import 包名;
 */
import cn.itcast.Teacher;//加载了cn.itcast包的Teacher类

public class Test {
	public static void main(String[] args) {
		Student s = new Student();
		s.show();
		
		/*
		//我要使用Teacher下的method()方法
		//类不在同一个包下，使用的时候，要加类的全路径名称
		cn.itcast.Teacher t = new cn.itcast.Teacher();
		t.method();
		t.method();
		
		cn.itcast.Teacher t2 = new cn.itcast.Teacher();
		t2.method();
		//这样做太麻烦了，java就提供了一个导包的功能
		 * 
		 */
		
		Teacher t = new Teacher();
		t.method();
		
	}
}

package javalearning;
public class Student {
	public void show() {
		System.out.println("show");
	}
}

package cn.itcast;
public class Teacher {
	public void method() {
		System.out.println("method");
	}
}

4.3四种权限修饰符的概述和访问特点

/*
 * 权限修饰符（是否可以访问）：
 * 				本类		同一个包下(子类和无关类)	不同包下(子类)	不同包下(无关类)
 * private:		Y
 * 默认:			Y			Y
 * protected:	Y			Y						Y
 * public:		Y			Y						Y				Y
 */

归纳一下：在日常开发过程中，编写的类、方法、成员变量的访问
A:要想仅能在本类中访问使用private修饰
B:要想本包中的类都可以访问除了private修饰符,其它都可以
C:要想本包中的类与其他包中的子类可以访问使用protected修饰
D:要想所有包中的所有类都可以访问使用public修饰。

4.3.1案例代码十六

package javalearning;

public class Test {
	public static void main(String[] args) {
		Father f = new Father();
		//f.show();
		f.show2();
		f.show3();
		f.show4();
	}
}

package javalearning;

public class Son extends Father {
	public static void main(String[] args) {
		Father f = new Father();
		//f.show();//报错
		f.show2();
		f.show3();
		f.show4();
		
		Son s = new Son();
		s.show2();
		s.show3();
		s.show4();
	}
}

package javalearning;
/*
 * 权限修饰符（是否可以访问）：
 * 				本类		同一个包下(子类和无关类)	不同包下(子类)	不同包下(无关类)
 * private:		Y
 * 默认:			Y		Y
 * protected:	Y		Y					Y
 * public:		Y		Y					Y			Y
 */
public class Father {
	private void show() {
		System.out.println("show");
	}
	
	void show2() {//默认修饰符
		System.out.println("show2");
	}
	
	protected void show3() {
		System.out.println("show3");
	}
	
	public void show4() {
		System.out.println("show4");
	}
	
	public static void main(String[] args) {
		Father f = new Father();
		f.show();
		f.show2();
		f.show3();
		f.show4();
	}
}