java封装性、继承性及关键字

方法的参数传递（重点、难点）
1.形参：方法声明时，方法小括号内的参数
   实参：调用方法时，实际传入的参数的值

2.规则：java中的参数传递机制：值传递机制

1）形参是基本数据类型的：将实参的值传递给形参的基本数据类型的变量

public static void main(String[] args) {
	TestArgsTransfer tt = new TestArgsTransfer();
 
	int i = 10;
	int j = 5;
	System.out.println("i:" + i + " j:" + j);//i : 10  j : 5
 
//		//交换变量i与j的值
//		int temp = i;
//		i = j;
//		j = temp;
	tt.swap(i, j);//将i的值传递给m，j的值传递给n
 
	System.out.println("i:" + i + " j:" + j);//i : 10  j : 5
 
}
//定义一个方法，交换两个变量的值
public void swap(int m,int n){
	int temp = m;
	m = n;
	n = temp;
	System.out.println("m:" + m + " n:" + n);

　

2）形参是引用数据类型的：将实参的引用类型变量的值（对应的堆空间的对象实体的首地址值）传递给形参的引用类型变量。

public class TestArgsTransfer1 {
	public static void main(String[] args) {
		TestArgsTransfer1 tt = new TestArgsTransfer1();
		DataSwap ds = new DataSwap();
 
		System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);
 
		tt.swap(ds);
		System.out.println(ds);
 
		System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);
 
	}
	//交换元素的值
	public void swap(DataSwap d){
		int temp = d.i;
		d.i = d.j;
		d.j = temp;
		System.out.println(d);//打印引用变量d的值
	}
}
 
class DataSwap{
	int i = 10;
	int j = 5;

一、面向对象的特征一：封装与隐藏
  问题：当创建了类的对象以后，如果直接通过"对象.属性"的方式对相应的对象属性赋值的话，可能会出现不满足实际
             情况的意外，我们考虑不让对象来直接作用属性，而是通过"对象.方法"的形式，来控制对象对属性的访问。实际
             情况中，对属性的要求就可以通过方法来体现。

二、面向对象思想的落地法则二：
  （封装性的思想）①将类的属性私有化，②提供公共的方法（setter & getter）来实现调用。

三、四种权限修饰符
    1.权限从大到小为：public protected 缺省 private
    2.四种权限都可以用来修饰属性、方法、构造器
    3.修饰类的话：public 缺省

　

this关键字：
 1.使用在类中，可以用来修饰属性、方法、构造器
 2.表示当前对象或者是当前正在创建的对象
 3.当形参与成员变量重名时，如果在方法内部需要使用成员变量，必须添加this来表明该变量时类成员
 4.在任意方法内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性
 5.在构造器中使用“this(形参列表)”显式的调用本类中重载的其它的构造器
   5.1 要求“this(形参列表)”要声明在构造器的首行！
   5.2 类中若存在n个构造器，那么最多有n-1构造器中使用了this。

public class TestPerson {
	public static void main(String[] args) {
		Person p1 = new Person();
		System.out.println(p1.getName() + ":" + p1.getAge());
 
		Person p2 = new Person("BB",23);
		int temp = p2.compare(p1);
		System.out.println(temp);
	}
}
class Person{
 
	private String name;
	private int age;
 
	public Person(){
		this.name = "AA";
		this.age = 1;
	}
 
	public Person(String name){
		this();
		this.name = name;
	}
	public Person(String name,int age){
		this(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 void eat(){
		System.out.println("eating");
	}
	public void sleep(){
		System.out.println("sleeping");
		this.eat();
	}
	//比较当前对象与形参的对象的age谁大。
	public int compare(Person p){
		if(this.age > p.age)
			return 1;
		else if(this.age < p.age)
			return -1;
		else
			return 0;
	}
 
}

package:声明源文件所在的包，写在程序的第一行。
  每“.”一次，表示一层文件目录。
  包名都要小写。
import:
 1)显式导入指定包下的类或接口
 2)写在包的声明和源文件之间
 3)如果需要引入多个类或接口，那么就并列写出
 4)如果导入的类是java.lang包下的，如：System String Math等，就不需要显式的声明。
 5)理解.*的概念。比如java.util.*;
 6)如何处理同名类的导入。如：在util包和sql包下同时存在Date类。
 7)import static 表示导入指定类的static的属性或方法
 8)导入java.lang.*只能导入lang包下的所有类或接口，不能导入lang的子包下的类或接口

面向对象特征二：继承性

通过"class A extends B"类实现类的继承。
 子类：A 父类（或基类 SuperClass）：B

子类继承父类以后，父类中声明的属性、方法，子类就可以获取到。
  明确：当父类中有私有的属性或方法时，子类同样可以获取得到，只是由于封装性的设计，使得子类不可以直接 调用罢了。

子类除了通过继承，获取父类的结构之外，还可以定义自己的特有的成分。

extends：子类是对父类功能的“扩展”，明确子类不是父类的子集。

.java中类的继承性只支持单继承：一个类只能继承一个父类。反之，一个父类可以有多个子类。
 子父类是相对的概念。

方法的重写（override orverwrite） vs 重载（overload）

方法的重载与重写的区别？
重载：“两同一不同”：同一个类，同一个方法名，不同的参数列表。 注：方法的重载与方法的返回值无关！
>构造器是可以重载的
重写：（前提：在继承的基础之上，子类在获取了父类的结构以后，可以对父类中同名的方法进行“重构”）
方法的返回值，方法名，形参列表形同；权限修饰符不小于父类的同名方法；子类方法的异常类型不大于父类的；
两个方法要同为static或同为非static。

super关键字：

1.super，相较于关键字this，可以修饰属性、方法、构造器

2.super修饰属性、方法：在子类的方法、构造器中，通过super.属性或者super.方法的形式，显式的调用父类的指定
属性或方法。尤其是，当子类与父类有同名的属性、或方法时，调用父类中的结构的话，一定要用“super.”

3.通过“super(形参列表)”，显式的在子类的构造器中，调用父类指定的构造器！
>任何一个类(除Object类)的构造器的首行，要么显式的调用本类中重载的其它的构造器“this(形参列表)”或显式的调用父类中
指定的构造器“super(形参列表)”,要么默认的调用父类空参的构造器"super()"
>建议在设计类时，提供一个空参的构造器！

用new调用子类构造器来创建子类对象之前必须现在子类构造器中调用一个父类构造器来初始化父类，以保证子类能够使用父类继承下来的成员。
子类构造器使用super隐式或显式来调用父类构造器的。隐式是指在子类构造器中没有使用super和this时，系统自动在子类构造器中第一行语句之前隐式默认加上super（）来调用父类无参构造器，此时如果
父类没有super（）所对应的无参构造器，则会出错，反之显式使用super或this时，系统不会在此子类构造器中再提供隐式的super（），即会显式使用的super或this来替代隐式的super（）。
因为隐式的速配而（）默认是在第一行语句之前，所以显式使用的super需要放在第一行才可以覆盖隐式的super（）。
那么this也必须放在第一行，是应为有this的构造器不再有任何的super，表面是不能直接调用父类构造器，但是this调用了子类中的其他构造器，这个被调用的子类构造器里有super来调用父类构造器，所以有this的构造器只是间接的通过子类中的其他构造器来调用父类构造器，所以this放在第一行。

　***宠物练习***

package petlianxi;
 
public class Pet {
   String name;
   private int age;
   private int helthy;
   private int hungry;
   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 int getHelthy() {
	return helthy;
}
 
public void setHelthy(int helthy) {
	this.helthy = helthy;
}
 
public int getHungry() {
	return hungry;
}
 
public void setHungry(int hungry) {
	this.hungry = hungry;
}
 
public int getHappy() {
	return happy;
}
 
public void setHappy(int happy) {
	this.happy = happy;
}
 
private int happy;
 
   public void Showinfo(){
	   System.out.println(name);
	   System.out.println(age);
	   System.out.println(helthy);
	   System.out.println(hungry);
	   System.out.println(happy);
   }
 
   public void eat(){
	   if(!check1()){
		   System.out.println("你家宝宝生病了");
	   }
	   System.out.println("宝宝吃饱饱了。。。");
       this.helthy+=5;
       this.hungry-=10;
       this.happy+=5;
   }
   public boolean check1(){
	   if(helthy>0&&hungry>0&&happy>0){
		   return true;
		 }else if(hungry<0){
			 hungry=0;
		 }
		 else if(helthy<0){
			 helthy=0;
		 }
		 else if(happy<0){
			 happy=0;
		 }return false;
 
   }
   public void play(){
	   if(!check1()){
		   System.out.println("你家宝宝生病了");
	   }else{
		   System.out.println("宝宝好高兴。。。");
	       this.helthy+=6;
	       this.hungry+=5;
	       this.happy-=18; }
   }
 
   public Pet(){
 
   }
 
   public Pet(String name){
	   this.name=name;
	   this.age=1;
	   this.helthy=100;
	   this.happy=80;
	   this.hungry=80;
   }
}
package petlianxi;
 
public class cat extends Pet{
  String sex;
  String name;
  public cat(String name,String sex){
		/*super.setName(name);*/
		this.sex=sex;
		super.name=name;
		this.name=name;
	}	
 
}
package petlianxi;
 
import java.util.Scanner;
 
public class text {
 
	public static void main(String[] args) {
	cat c=new cat("huahua","男");
	Scanner sc=new Scanner(System.in);
	boolean flag=true;
	while(flag){
		ShuoMing();
		String s=sc.nextLine();
		if("1".equals(s)){
			c.Showinfo();
		}else if("2".equals(s)){
			c.eat();
		}else if("3".equals(s)){
			c.play();
		}else if("bye".equals(s)){
			flag=false;
		}
	}sc.close();
 
	}
	 public static void ShuoMing(){
		 System.out.println("1--宝宝状态");
		 System.out.println("2--喂宝宝吃饭");
		 System.out.println("3--与宝宝玩耍");
	 }
}

　　

public class backing {
  String customname;
  int yue;//余额
  int qianshu;
  public void cun(){
	yue+=qianshu;
	System.out.println("您的余额："+this.yue);
  }
  public void qu(){
	yue-=qianshu;
	if(!checkl()){//把判断语句放在运算后边因为只有运算过后才会知道剩余的钱数是否够取出的
		System.out.println("对不起，您的余额不足");
		yue+=qianshu;
	}
	System.out.println("您的余额："+this.yue);
  }
  public boolean checkl(){
	  if(yue<0){
		  return false;
	  }else{return true;}
  }
}
package bancking;
 
public class custom extends backing{
  int mima;
  public custom(String customname,int yue,int mima){
	  this.customname=customname;
	  this.yue=yue;
	  /*this.qianshu=qianshu;*/
	  this.mima=mima;
	  System.out.println("客户名: "+this.customname+" 余额: "+this.yue);
  }
 
}
package bancking;
 
import java.util.Scanner;
 
public class text {
 
	public static void main(String[] args) {
		custom cs=new custom("小王",30000,111111);
 
		Scanner sc=new Scanner(System.in);
		System.out.print("请输入您的银行卡密码");
 
		boolean flag=true;
		while(flag){
			cs.qianshu=sc.nextInt();
			if(cs.qianshu>0){
				cs.cun();
			}else if(cs.qianshu<0){
				cs.qianshu=cs.qianshu*-1;
				cs.qu();
			}if(cs.yue<0){
				flag=false;}
		}sc.close();
		}
	}