JAVA基础day5

参数传值机制

Java中，方法中所有参数都是“值传递”；若值为地址，能够改变对象的内容。

package

包名：域名倒着写。
package 一定写在非注释语句的第一句。

package +包名;

com.gao 和com.gao.car 这两个包不存在包含关系，是两个独立的包。

import

package cn.sxt.gao;

import cn.sxt.oo.User;  //表示导入了User类，法二
//import cn.sxt.oo.*;  //若想多次使用一个包中的不同类，也可写这样一句，不必多次import不同类，缺点：只是编译速度降低

import static java.lang.Math.*; //静态导入，导入这个包中的所有静态属性

public class Test{
	public static void main(String[] args){
//法一		cn.sxt.oo.User user = new cn.sxt.oo.User(); //引用cn.sxt.oo包的类（当应用类同名时多用此法）
		User user = new User();  //法二 
		
		System.out.println(Math.PI); //静态导入前
		System.out.println(PI);  //静态导入后
	}
}

继承（extends）

子类继承父类，除了构造方法，子类可以得到父类的其他全部方法和属性（实现代码重用）。
java中类只有单继承，接口可以多继承。

public class Text{
	public static void main(String[] args){
		Student stu = new Student();
		stu.name = "七哥";
		stu.height = 172;  
		stu.rest();  //能够使用Person中的内容

		Student stu2 = new Student("葫芦娃", 18, "码农");

		//instanceof关键字
		System.out.println(stu2 instanceof Student);  //判断stu2是不是Student的对象(类型)，返回true
		System.out.println(stu2 instanceof Person);  //返回true
		System.out.println(stu2 instanceof Object);  //返回true
		System.out.println(new Person() instanceof Student);  //返回false
	}
}

class Person /*extends Object*/ {  //默认继承Object类
	String name;
	int height;

	public void rest(){
		System.out.println("休息一波！");
	}
}

class Studen extends Person {  //继承了Person中的内容，实现代码重用
	String major;

	public void study(){
		System.out.println("学习五分钟!");
	}
	
	public Student(String name, int height, String major){
		this.name = name;
		this.height = height;
		this.major = major;
	}  //定义一个构造器

	public Student(String name, int height, String major){
	}//stu需要一个空构造器，再定义一个空构造器，实现构造器重载
}

重写（override）/覆盖

public class Test{
	public static void main(String[] args){
		Horse h = new House();
		h.run();
	}
}

class Vehicle {
	public void run(){
		System.out.println("跑。。。");
	}

	public void stop(){
		System.out.println("停止！！");
	}

	public Person WhoIsPsg(){
		return new Person();  //此.java文件与上面继承的.java文件放在同一个包下面
	}
	
}

class House extends Vehicle {
	public void run(){ //重写run方法
		System.out.println("四蹄翻飞，冲冲冲！");
	}
	//重写WhoIsPsg方法
	public Student WhoIsPsg(){
		return new Student();  //此.java文件与上面继承的.java文件放在同一个包下面，return 返回值必须小于父类（Object --> Person --> Student）
	}
}

toString方法的重写

public class Test{
	public static void main(String[] args){
		Test to = new Test();
		System.out.println(to.toString());   //输出"测试Object对象"
	}

	public String toString(){
		return "测试Object对象";
	}

}

equals方法的重写

public class Test{
	public static void main(String[] args){
		Object obj;
		String str;

		User u1 = new User(11111, "天天向上");
		User u2 = new User(11111, "好好学习");
		
		System.out.println(u1.equals(u2));
	}
}

class User {
	int id;
	String name;
	
	public User(int id, String name){
		super();	
		this.id = id;
		this.name = name; 
	}
	@override
	public boolean equals(Object obj){//id相同则返回true
		if (this == obj)
			return true;
		if(obj == null)
			return false;
		if(getClass() != obj.getClass())
			return false;
		User other = (User)obj;
		if(id != other.id)
			return false;
		return true;
	}
}

super关键字

可以通过super来访问父类中被子类覆盖的方法或属性。

public class Test{
	public static void main(String[] args){
		new ChildClass().f();
	}
}
class FatherClass{
	public int value;

	public void f(){
		value = 100;
		System.out.println("FatherClass.value=" + value);
	}
}
class ChildClass extends FatherClass {
	public int value;
	
	public void f(){
		super.f();  //调用父类对象的普通方法
		value = 200;
		System.out.println("ChildClass.value=" + value);
		System.out.println(value);
		System.out.println(super.value);  //调用父类对象的成员变量
	}
}

构造方法中的第一句(无论写不写)总是：super();来调用父类对应的构造方法。所以构造方法的调用顺序先向上追溯到Object，然后在依次向下执行类的初始化块和构造方法，直到当前子类为止。

public class Test{
	public static void main(String[] args){
		System.out.println("开始创建一个ChildClass对象。。。");
		new ChildClass();
	}
class FatherClass {
	public FatherClass(){
		super();
		System.out.println("创建FatherClass");
	}
}
class ChildClass extends FatherClass {
	public ChildClass(){
		super();
		System.out,println("创建ChildClass");
	}
}

程序运行结果：

封装

访问权限修饰符(可修饰类、变量、方法)。

修饰符	同一个类	同一个包中	子类	所有类
private	*（可被调用）
default	*	*
protected	*	*	*
public	*	*	*	*

public class Test{
	public static void main(String[] args){
		Human h = new Human();
//		h.age = 13; //这里会报错，不能调用不同类中private封装的变量或方法
}
class Human {
	private int age;

	void sayAge(){
		System.out.println(age);
	}
}
class Boy extends Human {
	void sayHello{
//	System.out.println(age); //子类无法使用父类的私有属性和方法
	}
}

封装的使用细节

类的属性一般都要用private封装；

public class Person{
	private int age;
//set、get方法在eclipse中单击右键-->source类面有快捷创建
	public void setAge(int age){  //用一个方法给别的类调用，还可以用该方法限制调用
		if(age >= 1 && age <= 130){
			this.age = age;
		}else{
			System.out.println("请输入正常年龄！");
		}
	}
}

多态

1、多态是方法的多态，多态与属性无关。
2、多态的存在要有3个必要条件：继承、方法重写、父类引用指向子类对象。

public class Test{
	public static void main(String[] args){
		Animal a = new Animal();
		animalCry(a);
	
		Dog d = new Dog(); 
		animalCry(d); //输出 汪汪汪！
		animalCry(new Cat()); //输出 喵喵喵！

		//插播内容，转型
		Animal d1 = new Dog();	//向上转型，编译器认为d1为Animal标签，实际上d1为Dog标签，主要看new后面的标签，尽量是编译器和实际上的保持一致
		Dog d2 = (Dog) d1;	//向下转型
		
	}
	//多态省去了方法重载的麻烦
	static void animalCry(Animal a){	//父类引用指向子类对象
		a.shout();
	}
}
class Animal{
	public void shout(){
		System.out.println("叫了一声!");
	}
}
class Dog extends Animal {  //继承
	public void shout(){  //方法重写
		System.out.println("汪汪汪!");
	}
}
class Cat extends Animal {	//继承
	public void shout(){	//方法重写
		System.out.println("喵喵喵!");
	}
}

final关键字

1、修饰变量：被修饰的变量不可改变，一旦赋了初值就不能被重新赋值；
2、修饰方法：该方法不可被子类重写，但是可以被重载；
3；修饰类：被修饰的类不能被继承。