了解Java程序之面向对象

面向对象

形式参数是引用类型和返回值是引用类型解析:
形式参数是基本类型对实际参数没有任何影响;
形式参数是引用类型:
具体类 :实际参数传递的是需要改具体类对象!
抽象类 :实际参数传递到的是需要改抽象类的子类对象
举例:jdk提供的Scanner类
构造方法
Scanner(InputStream source)
public abstract class InputStream :抽象类
接口:实际参数需要传递的是该接口的子实现类的对象
举例:
TreeSet 集合
public TreeSet(Comparator comparator)
构造方法中传递是一个接口类型：Comparato 接口

interface Work{
	void teach() ;
}

//定义一个类
class TeacherDemo{			
	public void function(Work w){//形式参数是一个接口类型,需要传递该接口的子实现类对象
						
		w.teach() ;				//Work w  = new Teacher(); 接口多态的方式
	}
}
//定义一个接口的子实现类
class Teacher implements Work{
	//重写teach(){}
	public void teach(){
		System.out.println("老师讲解JavaEE...") ;
	}
}

//测试类
class TeacherTest{
	public static void main(String[] args){
		//需求:需要访问TeacherDemo类中的function方法?
		//创建TeacherDemo类的对象
		TeacherDemo td = new TeacherDemo() ;
		//创建Work对象
		//Work w = new Work() ; // Work是抽象的; 无法实例化
		//通过接口多态实现
		Work work =  new Teacher();
		td.function(work);
	}
}

方法的返回值是引用类型
引用类型：
具体类：需要返回的该具体类的对象 类名 对象名 = new 类名();
抽象类：需要返回的该抽象类的字类对象 父类民 对象名 = new 字类名():抽象类多态
接口：需要 返回的是该接口的子实现类对象
接口名 对象名 = new 子实现类类名();接口多态

//定义一个抽象类
abstract class Worker{
	public abstract void work() ;
}

class WorkDemo{

	//成员方法
	public Worker show(){	//在此处补全代码
		
		//返回什么？
		//return ?
		//Worker woker = new Worker() ;	//不能实例化
		//return worker ;
		
		//通过抽象类多态
		//分步走
		//Worker worker = new Employee() ; //父类引用指向字类对象
		//return worker;
		
		//一步走
		return new Employee() ;//匿名对象	
	}
}
//定义一个抽象类的字类
 class  Employee extends Worker{
		//重写work方法
		public  void work() {
			System.out.println("日复一日的在coding...") ;
		}
}

//测试类
class WorkTest{
	public static void main(String[] args){
		//需求：需要访问WorkDemo类中的show方法
		//创建WorkDemo对象
		WorkDemo wd = new WorkDemo() ;
		//调用方法
		Worker w = wd.show() ;//相当于Woker w  = new Employee() ;  抽象类多态实现的
		w.work() ;//日复一日的在coding...
	}
}

包的概念:
包：在Java中，就是一个目录(文件夹)
关键字：package 是一个Java文件中最上面的部分
包划分为：单级包 com
HelloWorld.java
多级包 com.qianfeng.test
xxx.java
针对带包的类进行编译 ,两种方式:
方式1:手动式:
1)在指定目录下将当前java源文件进行编译 javac java文件(带后缀)
2)上述1)会将java文件编译为xxx.class文件
3)必须将当前对应的包名 com.qianfeng(com文件夹下存在一个子文件夹:qianfeng)
4)将刚才编译xxx.class文件存放在多级包底层目录下
5)运行文件必须带包名来运行
java 包名.类名
//java com.qianfeng.HelloWorld
方式2:自动式:
1) 指定目录下编译这个java源文件
javac -d . HelloWorld.java (-d 文件夹的参数 (包名省略 后面文件名称))
2)会自动生成指定的包名以及包名中的.class文件 HelloWorld.class
3)运行文件必须带包名来运行
java com.qianfeng.HelloWorld
修饰符
常见的修饰符:
权限修饰符:public ,默认的,private,protected
状态修饰符:static,final
抽象修饰符:abstract
修饰类:
public,默认的,final,abstract,protected public使用居多一些
修饰成员变量:
public static final :static和final的组合修饰
static :静态修饰遍历
final :常量
默认的: int num = 10 ;
//abstarct int num2 = 100 ; 非法的:错误的
修饰成员方法
public : public void method{}
默认的: void show(){}
public abstract : public abstract void study();
public final: public final void function(){}
public static :public static void method(){}
protected:受保护的方法 (底层给的 方法去使用:自定义的方法不建议使用protected)
使用的在最多的修饰:public
public(1) protected(2) 默认(3) private(4)
同一包类中 1 2 3 4 (本类中访问)
同一包子类,无关类 1 2 3
不同包子类 1 2
不同包无关类 1
权限优先级问题:public(建议) > protected > 默认的 > private
private私有的修饰:通常在类中的属性中使用
protected:受保护的: JavaAPI底层源码中使用居多 :修饰成员方法多一些
public : 自己在使用或者面试题中,使用居多!
默认的修饰符: 笔试题或面试题中出现!
内部类:
内部类:在一个类中定义了另一个类
在一个类A中定义了一个类B,将类B就称为类A的内部类!
类A就称为类B外部类
特点:内部类可以访问外部类的成员,包括私有!
外部类的成员访问内部类(成员内部类)的的成员,必须通过对象访问!
内部类的分类:
成员内部类:在外部类的成员位置定义的类
局部内部类:在外部类的成员方法中定义的类
成员内部类
外部类要访问成员内部类的成员
固定的格式:
外部类名.内部类名 对象名 = 外部类对象.内部类对象;

//外部类
class Outer{
	//成员变量
	private int num = 100 ;
	
	//成员内部类
	class Inner{
		public void show(){
			System.out.println(num) ;
			System.out.println("show Inner...") ;
		}
	}
}

//测试类
class OuterDemo3{
	public static void main(String[] args){
		
		//Outer outer = new Outer() ;
		//outer.show() ; //show()是Inner类的(成员内部类的)
		
		//仅限于:非静态的成员内部类!
		//外部类名.内部类名 对象名 = 外部类对象.内部类对象;
		Outer.Inner oi = new Outer().new Inner() ;
		oi.show() ;
	}
}

一个成员内部类的修饰符
private:保证数据的安全性
static: 作用:是为了方便访问
注意事项:
静态的成员内部类的成员只能访问外部类的静态的成员
跟静态成员内部类中的成员是否静态无关!

//外部类
class Outer{
	public int num = 100 ;
	public static int num2 = 50 ;
	
	//定义一个静态的成员内部类
	public static class Inner{
		//非静态的成员方法
		public void show(){
			//System.out.println(num) ;无法从静态上下文中引用非静态 变量 num
			System.out.println(num2) ;
		}
		
		public static void show2(){
			//System.out.println(num) ;//无法从静态上下文中引用非静态 变量 num
			System.out.println(num2) ;
		}
	}
}

//测试类
class OuterDemo4{
	public static void main(String[] args){
		//按照:外部类访问内部类的成员
		//外部类名.内部类名 对象名 = 外部类对象.内部类对象();
		//限定的新静态类
		//Outer.Inner oi = new Outer().new Inner();
		//oi.show();
		//oi.show2();
		
		//如果成员内部类是静态的,那么上面方式无效:
		//外部类名.内部类名 对象名 = new 外部类名.内部类名();
		Outer.Inner oi = new Outer.Inner() ;
		oi.show();
		oi.show2();
		
		//将Inner内部类外部类的静态成员,而show2()方法又是成员内部类的功能
		//静态可以被类名直接访问
		Outer.Inner.show2();
		
		//50
		//50

	}
}