面向对象2

一.gc垃圾回收机制

1)、jvm时刻监控堆中对象，按照一定的声明周期进行清理回收

2)、System.gc() ：起通知的作用，通知垃圾回收机制回收垃圾，但是是否回收，什么时候回收无法控制

其中一定会回收垃圾的情况：

• 匿名对象
• 对象无引用

3)、finalize() ：回收垃圾会先调用对象的这个方法

二.package包和导包

1)、定义

为了便于管理大型软件系统中数目众多的类，解决类的命
名冲突问题，Java 引入包(package)机制，提供类的多重类命名空间。

一般的命名为：公司域名倒写+功能名|模块名。

2)、package语句

指明该文件
中定义的类所在的包。（若缺省该语句，则指定为无名包）。

格 式 ： package com.shsxt.test;（package 语句中，用’.’来指明包（目录）的层次）

注：:不要定义与 jdk 相同的包，相同的类，否则会引起很多莫名其妙的问题

3)、import

不需要使用 import 的类有:

• 语言包（java.lang）下的类
• 同包下的类

模糊匹配: 降低编译效率,不会减低运行效率 如：java.util.*

静态导入: 只导入静态的内容 如：import static java.lang.Math.PI;

三.javabean 封装

1)、定义

封装（Encapsulation）是面向对象方法的重要原则，就是 把对象的属性和行为（或方法）结合为一个独立的整体，并 尽可能隐藏对象的内部实现细节。

2)、好处

1. 隐藏实现细节，提供公共的访问方式（设置器(设置私有属性的值)setter、访问器(获取私有属性的值)getter ）
2. 提高代码的复用性
3. 提高代码的安全性

3)、javabean标准的开发要求

• 类应该是公共的
• 至少存在一个空构造
• 私有的属性
• 提供公共的访问方式:setter、getter

4)、private是封装的一种体现

私有是封装,但是封装不仅仅是私有,如：方法,类..都是封装的体现

//公共类
public class Student01 {
	public String name;
	private int age; 		//	私有的属性
	public String gender;
	
	//创建一个空构造
	public Student01() {
	}

	public Student01(String name, int age, String gender) {
		this.name = name;
		if(age>0 && age<=150){
			this.age = age;
		}else{
			System.out.println("年龄不合法!!!");
		}
		this.gender = gender;
	}
	//提供公共访问方式setter
	//age的设置器
	//返回值:不需要     参数:需要 
	public void setAge(int age){
		if(age>0 && age<=150){
			this.age = age;
		}else{
			System.out.println("年龄不合法!!!");
		}
	}
	//提供公共访问方式getter
	//age的访问器
	//返回值:需要 返回值int age			参数:不想要
	public int getAge(){
		return age;
	}
	
	public void info(){
		System.out.println(name+"->"+age+"-->"+gender);
	}
	
}

四.继承 ——extends

类：是一系列对象的共性，是对对象的抽象

父类: 是一系列类的共性 ，是对类的抽象

1)、格式

子类 extends 父类

2)、继承的优点

• 提高代码的复用性
• 子类一旦继承父类,就可以使用父类中的内容

注：一类父类可以被多个子类继承,但是一个子类只能继承一个父类,java是单继承机制,但是可以多实现

面向对象的设计原则之一: 开闭原则,对修改关闭,对扩展开放

单继承的优点:使用简单

单继承的缺点:不便于后期维护

class Person{
	public String name;
	public int age;
	public String gender;
	
	//休息
	public void sleep(){
		System.out.println(name+"正在休息...");
	}
}
//子类 学生继承父类 Person
class Student extends Person{
	public String subject;  //新增-->扩展
	
	public Student() {
		// TODO Auto-generated constructor stub
	}
	
	//学习
	public void study(){
		System.out.println(name+"正在敲代码...");
	}
}


//教师类
class Teacher extends Person{
	public int javaClass;  //教师所授课的班级
	
	public Teacher() {
		// TODO Auto-generated constructor stub
	}
	
	//讲课
	public void teach(){
		System.out.println(name+"正在讲课...");
	}
}

五.权限修饰符

1)、权限修饰符

权限修饰符：public、protected、private、default

修饰符	本类	同包类	不同包子类	不同包
private	Y
default(默认)	Y	Y
protected	Y	Y	Y
public	Y	Y	Y	Y

注：

• 成员修饰符,只能修饰成员,不能修饰局部
• 修饰类的权限修饰符:public ,default(默认的)（default 类只可以在同包被访问 ）
• 私有内容不能被继承,静态的可以被继承

//父类
package test;
public class test1Package {
	public int tPublic=5;
	private int tPrivate=10;
	protected int tProtected=15;
	int tDefault=20;
}
//不同包子类
package son1;
//导包
import test.test1Package;

class Test extends test1Package{
	public static void main(String[] args){
	//不能使用父类创建对象调用父类的成员
		Test t=new Test();
		System.out.println(t.tPublic);
		System.out.println(t.tPrivate);		//报错
		System.out.println(t.tProtected);
		System.out.println(t.tDefault);		//报错
		
	}
}
//同包子类
package test;

class Son extends test1Package{
	public static void main(String[] args){
		Son s=new Son();
		System.out.println(s.tPublic);
		System.out.println(s.tPrivate);		//报错
		System.out.println(s.tProtected);
		System.out.println(s.tDefault);
		}
}

六.override

1)、重写的条件

• 不同的类
• 继承|实现
• 方法签名相同（方法签名：(方法名+参数列表））

2)、作用

子类一旦重写父类中的某个方法,子类对象调用的是子类中重写的方法,对父类同名方法屏蔽

package test;

public class Override01 {
	public static void main(String[] args) {
		Son1 s1 =new Son1();
		s1.usp();
		//运行结果为hello,dad,myfather
	}
}


class Father1{
	public Father1 usp(){
		System.out.println("hello,child,my son");
		return null;
	}

}


class Son1 extends Father1{
//重写	
	
	public Son1 usp(){
		System.out.println("hello,dad,myfather");
		return null;
	}
	
}

3)、检查是否为重写方法

• 左侧出现向上的三角形
• 注解 Override @注解名

4)、不能被重写

1. private修饰的方法不能被重写
2. final修饰的内容不能被重写
3. 被static修饰的内容不能被重写

注：如果子类中定义一个方法,在它的父类中有同名(方法签名)的静态方法,子类中的这个方法也必须是静态的

5)、重写的要求

• == : 方法签名必须完全相等
• <= : 返回值类型 : 基本数据类型必须相等, 引用数据类型:子类的返回值类型<=父类的返回值类型
• >= : 子类重写方法的的权限修饰符必须>=父类中这个方法的权限修饰符

package test;

public class Override01 {
	public static void main(String[] args) {
		Son1 s1 =new Son1();
		s1.usp();
		s1.sp();
		s1.sp(0);
	}
}

class Father1{
//引用数据类型
	public Father1 usp(){
		System.out.println("hello,child,my son");
		return null;
	}
	//权限修饰符
	protected void sp(){
		System.out.println("hello,child,my son");
		
	}
}


class Son1 extends Father1{
//重写	
	//引用数据类型
	public Son1 usp(){
		System.out.println("hello,dad,myfather");
		return null;
	}
//	重写
	//子类权限修饰符public大于父类protected
	public void sp(){
		System.out.println("hello,dad,myfather");
		
	}
	//构成重载
	void sp(int a){
		System.out.println("重载");
	}
	
}

七.super

1)、super与this的区别

this：指代当前new的对象

super：指代父类对象

注：super和this不能同时存在,因为都要在首行，如果存在this(),会在this调用的构造器首行调用父类构造器

2)、作用

在子类构造器首行调用父类中的某个构造器

注：如果没有显示调用,默认在*首行*调用父类空构造,如果一旦显示调用,就不会默认调用父类空构造器了

3)、步骤

创建对象: 先父类后子类

初始化: 先静态后成员

public class SuperDemo01 {
	public static void main(String[] args) {
		
		Zi zi=new Zi(123);
		zi.test();
	}
}

class Fu{
	String name;
	int age;
	int a;
	public Fu() {
		System.out.println("我是父类空构造");
	}
	
	public Fu(String name,int age) {
		System.out.println("我是父类带参构造");
		this.name=name;
		this.age=age;
	}
	
}

class Zi extends Fu{
	int a;
	public Zi() {
		System.out.println("我是子类空构造");
	}
	
	public Zi(int a) {
		this.a=a;
	}
	
	public Zi(String name,int age) {
		//this();
		super(name,age);
		System.out.println("我是子类带参构造");
	}
	
	void test(){
		int a=333;
		//a是成员,只能通过对象调用,默认this调用就近原则指代当前类
		System.out.println(a);
		System.out.println(this.a);
		System.out.println(super.a);  //super指代父类对象
		
	}
	
}

八.final

final修饰的变量为常量

final修饰的方法不能被重写

final修饰的类不能被继承(太监类)

public class FinalDemo02 {
	final F a=new F();  //a永远执行后面的对象,存储的对象地址永远不能改变
	public static void main(String[] args) {
		//对象的地址不改变,内存空间的值可以改变
		new FinalDemo02().a.money=10;
		
		//new FinalDemo02().a=new F();  重新指向了
		
		FinalDemo02 f=new FinalDemo02();
		f=new FinalDemo02();
		
	}
}

class F{
	int money=100;
	public  void test(){
		
	}
}
class Z extends F{
	public  void test(){
		
	}
}