java之面向对象

心已赠人 2022-01-15 18:31 215阅读 0赞

【类与对象】

类是静态的概念，在代码区。对象是new出来的，位于堆内存，类的每个成员变量在不同的对象中都有不同的值（除了静态变量）而方法只有一份，执行的时候才占有内存。

【构造方法】

在类中用来初始化对象的函数。与类同名没有返回值（不能添加void修饰符）。当不指定构造方法时，系统默认添加一个空的构造方法。指定后，系统则不自动添加。

【方法的重载】

在一个类中，可以定义有相同的名字，但参数不同的多个方法。调用时，会根据不同的参数表选择对应的方法。

【this】

在类的方法定义中使用，代表使用该方法的对象的引用。

当必须指出当前使用方法的对象是谁时，使用this。

有时使用this可以处理方法中成员变量和参数重名的情况。

this可以看做是一个变量，它的值是当前对象的引用。

例子：

public class ThisTest {
    	int i = 0;
    	ThisTest(int i) {
    		this.i = i;
    	}
    	ThisTest implement() {
    		i++;
    		return this;
    	}
    	void print() {
    		System.out.println("i的值为：" + i);
    	}
    	
    	public static void main(String[] args) {
    		ThisTest thisTest = new ThisTest(100);
    		thisTest.implement().implement().print();
    	}
    
    }

【static】

静态变量或方法，分布在data segment区。属于整个类，不属于单独的对象。在没有new对象的情况下，也可以访问静态变量或方法。

【package】

为便于管理大型软件系统中数目众多的类，解决类的命名冲突问题。Java引入“包”机制，提供类的多重类命名空间。package语句作为java源文件的第一条语句，指明该文件中定义的类所在的包。访问某个包内的类，需要通过import语句引入该目录。Java中类文件可以打包成一个jar文件来使用。

【继承】

使用extends关键字来实现类的继承机制。通过继承，子类自动拥有了父类的所有成员。Java只允许单重继承即一个子类只能有一个基类，而一个基类可以派生出多个子类。子类拥有父类private类型变量的所有权，而没有使用权。

【权限控制】

对于成员变量有四种访问权限public private protecteddefault

<table> 
 <tbody> 
 <tr> 
 <td> 修饰符 </td> 
 <td> 类内部 </td> 
 <td> 同一包 </td> 
 <td> 子类 </td> 
 <td> 在任何地方 </td> 
 </tr> 
 <tr> 
 <td> private </td> 
 <td> 可以访问 </td> 
 <td> &nbsp; </td> 
 <td> &nbsp; </td> 
 <td> &nbsp; </td> 
 </tr> 
 <tr> 
 <td> default </td> 
 <td> 可以访问 </td> 
 <td> 可以访问 </td> 
 <td> &nbsp; </td> 
 <td> &nbsp; </td> 
 </tr> 
 <tr> 
 <td> proteteed </td> 
 <td> 可以访问 </td> 
 <td> 可以访问 </td> 
 <td> 可以访问 </td> 
 <td> &nbsp; </td> 
 </tr> 
 <tr> 
 <td> public </td> 
 <td> 可以访问 </td> 
 <td> 可以访问 </td> 
 <td> 可以访问 </td> 
 <td> 可以访问 </td> 
 </tr> 
 </tbody> 
</table>

对于class只有两种访问权限，public和default，public类可以在任意地方被访问，default类只可以被同一个包内部的类访问。

【重写】

子类可以重写从父类继承下来的方法，重写的方法与被重写方法有相同的函数名，相同的参数列表和返回值，重写的方法不能比被重写方法有更高的访问权限。

【super】

java使用super来引用基类的成员。继承中的构造方法：

规则一：子类构造的过程必须调用其基类的构造方法。

规则二：子类可以在自己的构造方法中使用super调用基类的构造方法。使用this调用本来的另外的构造方法。如果调用了super，必须写在子类构造方法的第一行。

规则三：如果子类没有显示地调用基类构造方法，则系统默认调用基类无参数的构造方法。否则，编译会出错。

【Object类】

java中所有的类都从Object继承。Object类提供了toString、equals等方法，publicString toString()方法，其返回值是String类型，描述当前对象的有关信息，在进行String与其他类型数据的连接操作时，将自动调用该对象类的toString()方法。用户可以根据需要重写toString()方法。运算符“+”两侧的操作数只要有一个是字符串，系统自动将另一个转换为字符串然后再连接。

equals方法定义为x.equals(y)，当x和y是同一个对象的引用时，返回true，否则返回false。J2SDK提供的一些类，如String、Date等，重写了Object的equals方法，调用这些类的equals方法x.equals(y)，当x和y所引用的对象是同一类对象且属性内容相等时(并不一定是相同对象)，返回true否则返回false。

看下面的例子：

public class EqualsTest {
    	public static void main(String[] args) {
    		Object s1 = new String("Hello");
    		Object s2 = new String("Hello");
    		Object s3 = "Hello";
    		Object s4 = "Hello";
    		if(s1==s2) {
    			System.out.println("s1 == s2");
    		}
    		if(s1.equals(s2)) {
    			System.out.println("s1 equals s2");
    		}
    		if(s3==s4) {
    			System.out.println("s3 == s4");
    		}
    		if(s3.equals(s4)) {
    			System.out.println("s3 equals s4");
    		}
    		if(s1==s3) {
    			System.out.println("s1 == s3");
    		}
    		if(s1.equals(s3)) {
    			System.out.println("s1 equals s3");
    		}				
    	}
    }

程序运行的结果是：

s1 equals s2

s3 == s4

s3 equals s4

s1 equals s3

原理其实很简单：“==”比较的是对象的地址，equals比较的是内容，而且使用new创建对象和直接定义一个对象的内存分布是不同的：

1、直接创建对象

![SouthEast][]

2、使用new创建对象

![SouthEast 1][]

【对象转型】

规则一：基类的引用类型变量可以“指向“其子类的对象。