Java面向对象（中）

最新推荐文章于 2022-12-27 11:04:33 发布

哈李波特

最新推荐文章于 2022-12-27 11:04:33 发布

阅读量496

点赞数

本文链接：https://blog.csdn.net/LB0420/article/details/45564611

版权

1.方法参数传递
在Java中无论基本数据类型还是引用数据类型都是采用的值传递的方式(也就是说传递的是一个具体的值)。

引用类型在进行参数传递时，传递的是当前内容的物理内存地址，所以在目标方法中进行修改，参数本身也会发生变化。

基本数据类型在进行参数传递时，传递的是当前值的副本，所以在目标方法中进行修改，参数本身不会发生变化。

/**

	基本数据类型参数的传递
*/


public class Test2{

	public static void main(String[]args){

		int x=100;
		Test2 t=new Test2();
		System.out.println("在调用display方法之前x的值是："+x);

		t.display(x);

		System.out.println("在调用display方法之后x的值是:"+x);
	}


	public void display(int num){
		System.out.println("display方法中num的值是:"+num);
		num=9000;
		System.out.println("重新赋值后num的值是:"+num);
	}
}

2.JavaBean

规范：
1.所有属性私有[private]

2.提供一个无参数的公共的构造方法
3.为所有的私有属性提供公共的set和get方法。

/**

	JavaBean 定义示例
*/

public class JavaBean{


	private String name;
	private int age;
	private float score;

	public JavaBean(){

	}

	public void setName(String name){

		this.name=name;
	}

	public String getName(){
		return name;
	}

	public void setAge(int age){
		this.age=age;
	}
	public int getAge(){
		return age;
	}

	public void setScore(float score){
		this.score=score;
	}
	public float getScore(){
		return score;
	}
}

注意：
set和get方法命名规则：
setXxx(数据类型参数名)

getXxx(){

}

Xxx就是属性名称，第一个字母大写。

作用：
就是用来进行临时存储数据。

3.package打包
为了便于管理大型软件系统中数目众多的类，解决类命名冲突的问题，Java引入了包（package）。在使用许多类时，类和方法的名称很难决定。有时需要使用与其他类相同的名称。包基本上隐藏了类并避免了名称上的冲突。用package来声明包，package语句必须是java源文件中的第一条语句。(若无这条语句，则放置在无名包下) 在package语句中，用"."来指明包（目录）的层次。包对应着文件系统的目录层次结构。

编译带包的类语法：
javac -d . 类名.java或者
javac -d 目录类名.java

执行字节码时，语法：
java 包名.类名

包名.类名又叫类的全限定名。

4.java.lang －包含一些Java语言的核心类，如：String、Math、Integer、System和Thread，提供常用功能。
此包因为非常常用，所以在任何类中不用导入就可能直接使用。

5.继承
在Java中可以通过"is-a"来判断两个事物之间是否存在继承关系。

特点：
1.继承需要有一定的层次结构，并且具有可传递性。

2.在Java中子类继承了父类中所有的属性和方法，但是构造方法和私有属性除外。

3.子类除了继承父类的某些属性和方法以外，还可以拥有自己的属性和方法。

4.在java中一个子类只能有一个父类，但是一个父类可以拥有多个子类。也就是说java中只支持单一继承。

作用：
提高代码的重用性。

在Java中通过extends关键字实现继承。
[访问修饰符] class 子类 extends 父类{

}

注意：
当创建子类对象时，一定会先执行父类中的构造方法，然后再执行子类中的构造方法；如果没有明确指明，则调用父类中默认的构造方法。

/**

	继承
*/

class Father extends Object{

	String money="999999999999999$";
	String house="100栋别墅";
	String car="10辆法拉利";

	public Father(){
		System.out.println("父类中的构造方法");
	}

	public void makeMoney(){

		System.out.println("24小时造钱");
		
	}
}

class Son extends Father{

	public Son(){
		System.out.println("子类中的构造方法");
	}
	public void play(){

		System.out.println("继承了父类的财产:"+money+"  "+house+"  "+car);

		makeMoney();
	}
}

public class Test5 extends Object{

	public static void main(String[]args){
		Son son=new Son();
		System.out.println(son.toString());
		son.play();
	}
}

6.super关键字

目的：就是显示的告诉我们当前这个属性或方法来自于父类。
作用：super表示对当前类父类对象的引用（也就是说super可以表示父类的某个对象）。

注意：super关键字只能用在有继承关系的子类中。

super调用父类中的属性和方法，用法：
super.属性名;
super.方法名(参数列表);

如果super(参数列表)的形式出现在子类构造方法的第一句代码时，就表示明确指明了父类的构造方法来创建父类对象。

/**

	继承
*/

class Father{

	String money="999999999999999$";
	String house="100栋别墅";
	String car="10辆法拉利";

	public Father(String a){
		System.out.println("父类中的构造方法"+a);
	}

	public void makeMoney(){

		System.out.println("24小时造钱");
		
	}
}

class Son extends Father{

	public Son(){
		super("ok");
		System.out.println("子类中的构造方法");
	}
	public void play(){

	System.out.println("继承了父类的财产:"+super.money+"  "+super.house+"  "+super.car);

		super.makeMoney();
	}
}

public class Test6{

	public static void main(String[]args){
		Son son=new Son();
		son.play();
	}
}

7.访问修饰符

private修饰的属性或方法只能在本类中访问。默认修饰的属性或方法只能在本类或同一个包中的类。

protected修饰的属性和方法只能在本类或同一个包中的类或者不同包内的子类中访问。
注意：protected修饰的属性如果在子类中访问，只能通过父类对象或者直接对属性访问，在子类中不能通过创建父类对象访问protected修饰的属性。

public修饰的属性和方法任何一个类都可以访问。

注意：类一般用public或默认的修饰符。

8.Object类
java.lang.Object类是所有类的父类.
如果在创建类时，没有明确指明父类，则默认继承自Object类。

Object类中的toString()方法，可以输出对象的字符串值，表示形式为类名@对象的十六进制哈希码值。
9.final关键字
1.final修饰变量，则变量称为常量。

2.final修饰方法中的参数称为最终参数，一旦赋值同样不能更改。

3.final修饰类，则该类不能被继承。

4.final修饰方法，方法不能被重写。

/**

	final 关键字
*/

public class Test9{

	public static void main(String[]args){

		F f=new F();
	}

	public void test(final int num){

		num=1000;
	}
}

final class F{


}

class S extends F{

}

10.方法重写前提条件：方法重写只能出现在有继承关系的子类中，也就是说只能是子类重写父类的方法。

目的：当父类的方法，不能满足子类的需求时，子类可以对父类的方法进行修改。

重写的定义：子类重写父类的方法，需要和父类中的方法名称，参数列表，返回值类型完全一致，而且访问修饰符的范围不能缩小。

/**
	方法重写
*/

class F1{

	public void display(){

		System.out.println("房地产");
	}
}

class S1 extends F1{

	public void display(){

		super.display();

		System.out.println("互联网金融P2P");
	}
	
	public void test(){
		System.out.println("test");
	}
	
}

class S2 extends F1{


}

public class Test10{

	public static void main(String[]args){
                F1 f=new S1();
		S1 s=(S1)f;  //向下转型
                s.display();
		System.out.println(s instanceof F1);
		System.out.println(f instanceof S1);

	}
}

11.向上转型/向下转型

向上转型就是说创建一个子类对象，赋值给父类，这时候就发生了向上转型。

动态绑定机制(延迟绑定)：在程序执行时，JVM会判断对象的真正的创建者，谁创建的对象就调用谁的方法.

发生动态绑定机制的条件：

  1.要有继承
  2.要有重写
  3.要有向上转型
  4.用向上转型的对象调用被重写的方法。

向下转型，就是说在向上转型基础上进行类型的还原。

可以通过instanceof 关键字来判断当前对象是否属于该类。

语法：
对象名称 instanceof 类名/接口;