day8面向对象3

final关键字：（最终的意思）

可以修饰类，变量，修饰方法
修饰类：表示是最终的类，无法继承
修饰变量：表明该变量是常量
修饰方法：表示该方法是最终方法，不能被重写

static关键字（ 静态的意思）

可以修饰成员变量和成员方法

静态成员的特点
 a，被类的所有对象共享
 b，通过类名直接可以访问
 c，优先于对象存在
 d，随着类的加载而加载

非静态的成员方法

1，能访问静态的成员变量
2，能访问非静态的成员变量
3，能访问静态的成员方法
4，能访问非静态的方法

静态的成员方法

1，能访问静态的成员方法：
2，能访问静态的成员变量

静态的方法中不能存在this，super的关键字
原因：静态是随着类的加载而加载，this super这样的关键字是随着对象的创建而存在

先进内存的，是不能访问后进内存的

抽象类：

1，抽象方法和抽象类必须用abstract关键字
2，有抽象方法的类一定是抽象类
3，抽象类不能实例化
	如何实例化
	参照多态的方式，通过子类进行实例化
4，抽象类的子类
	要么重写抽象类中的所有抽象方法；
	要么子类也是抽象类

抽象类的成员特点

1，成员变量
	可是是常量，也可以是变量
2，构造方法
	有构造方法，
	用于子类访问父类的初始化
3，成员方法
	成员方法可以是抽象，也可以不是抽象的
	抽象方法---限定子类必须完成某种方法
	非成员方法：提高代码的复用性

抽象类的练习

public abstract class teacher {
	private String name;
	private int age;
	//alt + /
	public teacher(){
		
	}
	//atl+shift +s+o
	public teacher(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 teach();
}

public class base extends teacher{

	@Override
	public void teach() {
		// TODO Auto-generated method stub
		System.out.println("基础班老师");	
	}
	 public base(){}
	 public base(String name,int age){
		 super(name,age);
	 }
}

public class testbase {
	public static void main(String[] args) {
		teacher t=new base();
		t.setName("呵呵");
		t.setAge(30);
		t.teach();
		
		System.out.println(t.getName()+t.getAge());
	}
}

接口

a，定义接口使用的是interface接口
b，类和接口之间是实现关系  implements 
c，接口不能实例化
		参照多态的形式使用实现类的实例化
d，接口的实现类
	要么重写接口的所有的抽象方法
	要么是一个抽象类	

多态的几种形式
具体类（几乎不用）
抽象类（常用）
接口多态（最常用）

接口的成员特点

成员变量
	：有成员变量，而且只能是常量
	public static final....

构造方法（没有构造方法）

成员方法
	接口有成员方法，而且都是抽象的
	默认修饰符：public abstract

类与类 类与接口 接口与接口

类与类：(extends)
		继承关系，只能单继承，可以多层继承
类与接口：(implement)
		实现关系，可以单实现，也可以多实现
		还可以在继承一个类的同时  实现多个接口
接口与接口(extends)
		继承关系，可以单继承，也可以多继承

抽象类和接口的区别

1，成员区别：
抽象类：
成员变量：可以是变量和常量
构造方法：有
成员方法：可以是抽象方法，也可以是非抽象方法
接口：
成员变量：只能是常量
成员方法：只能是抽象方法
2，关系区别
类与类：继承关系，只能单继承，可以多层继承
类与接口：实现关系，可以单实现，也可以多实现
接口与接口：继承关系，可以单继承，也可以多继承
3，设计理念
抽象类 is a（定义的是继承体系的共性功能）
接口类 like a（定义该体系的扩展功能）

接口的练习

public interface english {
	public abstract void english();
}

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();
}

public abstract class player extends person  {
	public player(){
		
	}
	public player(String name ,int age){
		super(name,age);
	}
	
	public abstract void study();
}

	public abstract class jiaolian extends person {
	public jiaolian(){
		
	}
	public jiaolian(String name,int age){
		super(name,age);
	}
	public abstract void teach();
}

public class pp extends player implements english {
	public pp() {
	}
	public pp(String name, int age) {
		super(name, age);
	}
	@Override
	public void english() {
		System.out.println("乒乓球运动员说英语");
	}
	@Override
	public void study() {
		System.out.println("乒乓球运动员学习如何发球个接球");

	}
	@Override
	public void eat() {
		System.out.println("乒乓球运动员吃牛肉");
	}
}

public class ppjiaolian extends jiaolian implements english{
	public ppjiaolian(){		
	}
	public ppjiaolian(String name ,int age){
		super();
	}	
	@Override
	public void teach() {
		System.out.println("乒乓球教练吃的好");		
	}
	@Override
	public void eat() {
		System.out.println("乒乓球教练吃牛肉");		
	}
	@Override
	public void english() {
		System.out.println("乒乓球教练说英语");		
	}
}

public class test1 {
	public static void main(String[] args) {
		pp p=new pp("张继科",30);
		System.out.println(p.getName()+p.getAge());
		p.eat();
		p.study();
		p.english();		
	}
}

包的概念

包的概念

包就是文件夹
作用：对类进行分类管理
包的定义：
package 包名
如果是多级的包，隔离即可
注意：
1，包必须是第一条执行语句
2，在一个java文件中只能有一个

导包

import 包名；

四种权限修饰符

java 转型问题其实并不复bai杂，只要记住一句话：父类du引用指向子类对象。zhi
什么叫父类引用指dao向子类对象，且听我慢慢道来.
从2个名词开始说起：向上转型(upcasting) 、向下转型(downcasting).
举个例子：有2个类，Father是父类，Son类继承自Father。
Father f1 = new Son(); // 这就叫 upcasting （向上转型)
// 现在f1引用指向一个Son对象
Son s1 = (Son)f1; // 这就叫 downcasting (向下转型)
// 现在f1还是指向Son对象
第2个例子：
Father f2 = new Father();
Son s2 = (Son)f2; // 出错，子类引用不能指向父类对象
你或许会问，第1个例子中：Son s1 = (Son)f1;问什么 是正确的呢。
很简单因为f1指向一个子类对象，Father f1 = new Son(); 子类s1引用当然可以指向子类对象了。
而f2 被传给了一个Father对象，Father f2 = new Father（）；子类s1引用不能指向父类对象。
总结：
1。父类引用指向子类对象，而子类引用不能指向父类对象。
2。把子类对象直接赋给父类引用叫upcasting向上转型，向上转型不用强制转换。
如：Father f1 = new Son();
3。把指向子类对象的父类引用赋给子类引用叫向下转型(downcasting)，要强制转换。
如：f1 就是一个指向子类对象的父类引用。把f1赋给子类引用s1即 Son s1 = (Son)f1；
其中f1前面的(Son)必须加上，进行强制转换。