《java开发实战经典》李兴华——C5. 面向对象（基础篇）

最新推荐文章于 2021-02-27 01:56:21 发布

Monica_xxt

最新推荐文章于 2021-02-27 01:56:21 发布

阅读量610

点赞数 1

本文链接：https://blog.youkuaiyun.com/weixin_41590506/article/details/81368239

版权

本文详细介绍了Java面向对象编程的基础概念，包括封装性、继承性和多态性的特点。通过实例讲解了类与对象的关系、构造方法、匿名对象、String类的使用以及引用传递等核心知识点。此外，还探讨了构造方法私有化实现单例设计模式的原理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、面向对象的基本概念

1.面向对象的3个主要特征：

（1）封装性：把描述对象属性的变量及实现对象功能的方法合在一起，定义成一个程序单位，并保证外界不能随意更改其内部属性值，也不能随意调动其内部的方法。

（2）继承性：子类（派生类）&父类（超类）；单继承&多继承。

注：java类不能多继承，但是接口可以。

（3）多态性：多态是允许程序中出现重名的现象。java中包含如下两种形式的多态：

1）方法重载：同一个类中，多个方法使用同一个名字，但方法参数不同，实现功能也不同。

2）对象多态：子类对象可以与父类对象相互转换。

二、类与对象

1.类与对象关系：

2.类的定义：

类由属性和方法组成：

3.对象的创建及使用：

1）创建对象：

类名对象名 = new 类名（）；//创建并实例化对象

2）访问对象中属性或方法：

访问属性：对象名称.属性名；

访问方法：对象名称.方法明（）；

注意：对象使用前必须实例化。

三、封装性

class Person{
	String name;
	int age;
	public void tell() {
		System.out.println("姓名："+ name+"; 年龄："+ age);
	}
}

public class Test {
	public static void main(String[] args) {
		Person per = new Person();
		per.name = "Monica";
		per.age = -22;
		per.tell();
	}
}

运行结果：姓名：Monica; 年龄：-22

我们知道age不应该赋值为负数，导致这种问题的原因是赋值时没有加以检验，所有程序都可以直接用对象访问类中的属性。为了避免，一般在类中用private修饰属性进行封装，如下：

class Person{
	private String name;
	private int age;
	public void tell() {
		System.out.println("姓名："+ name+"; 年龄："+ age);
	}
}

public class Test{
	public static void main(String[] args) {
		Person per = new Person();
		per.name = "Monica"; //编译报错
		per.age = -22;       //编译报错
		per.tell();         
	}
}

此时用对象直接访问属性会报错。

解决方法：Java中，访问被封装的属性必须通过setter和getter方法设置和获得。

如下：

class Person{
	private String name;
	private int age;
	public void tell() {
		System.out.println("姓名："+ getName()+"; 年龄："+ getAge());
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
                if(age>=0){
		    this.age = age;
                }
	}
}

public class Test{
	public static void main(String[] args) {
		Person per = new Person();
		per.setName("Monica");
		per.setAge(-22);
		per.tell();
	}
}

此时运行结果：姓名：Monica ；年龄：0

因为age的值不符合setter的条件，因此没有被成功赋值，age属性值为默认的初始值0.

注意:

1.本类中方法的调用：直接写方法名即可，但是最好采用" this.方法名()"的形式。

2.对类中属性进行封装时，所有属性都要封装。

3.类外部访问被封装的属性时，要通过getter/setter方法。

四、构造方法

1.作用：实例化一个类的对象后，不用通过setter方法赋值，有了构造方法，在对象实例化时直接把对象的值赋给属性。

2.构造方法定义格式：

如果一个类中没有声明构造方法，那么编译时会自动生成一个无参的、什么都不做的构造方法。

3.通过构造方法为属性赋值：

class Person{
	private String name;
	private int age;
	
	public Person(String name, int age){
		this.setName(name);
		this.setAge(age);
	}
	public void tell() {
		System.out.println("姓名："+ getName()+"; 年龄："+ getAge());
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		if(age>=0) {
			this.age = age;
		}
	}
}

public class Test{
	public static void main(String[] args) {
		Person per = new Person("Monica",22);//调用构造方法，传递两个参数
		per.tell();
	}
}

4.构造方法重载：

与普通方法一样，只要参数类型或个数不同即可重载。

五、匿名对象

1.定义：没有给出明确名字的对象

一般匿名对象只使用一次，并且匿名对象只在堆内存中开辟，不存在栈内存的引用。

2.匿名对象的使用：

public class Test{
	public static void main(String[] args) {
		new Person("Monica",22).tell();//匿名对象的使用
	}
}

六、String

1.String内容比较：

内容比较时：基本数据类型，用 ==

String 用 equals（）方法

注意：

1）用==比较String：

public class Test{
	public static void main(String[] args) {
		String a ="hello";
		String b ="hell"+"o";
		String c = new String("hello");
		String d = a;
                String m ="hell";
		String n = "o";
		String k =m+n;
		System.out.println(a==b);  //true   注意：这个是true
                System.out.println(a==k);  //false  注意：这个是false
                System.out.println(a==c);  //false 	
		System.out.println(b==c);  //false
		System.out.println(a==d);  //true
	}
}

2）equals方法实现过程：

    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {  //instanceof用于判断anObject是不是String类的对象
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

2.String 两种实例化方式对比：

1）直接赋值：String a = "hello";

2) new 调用构造方法：String a = new String("hello");

分析：

1）

一个字符串就是一个String类的匿名对象，因此已经开辟了一个堆内存空间并可以直接使用。

所以String a = "hello"，实际就是把一个堆中的内存空间的使用权给了a。

因此如果再声明一个String b = "hello"，就是把该堆的使用权又交给了b，此时a==b。

这一点在Java中成为共享设计，即当内容重复时，会将对象指向已存在的实例空间。

2）new 不管如何都会开辟一个新的堆内存空间。

3.String 内容不可变性：

Stirng str = ""hello;
str = str+" world!";

4.String类中常用方法

1)字符串与字符数组的转换

String str1 = "hello";//字符串
char [] arr = str1.toCharArray();//字符串转数组，结果['h','e','l','l','o']
String str2 = new String(arr);//数组转字符串，结果"hello"
String str3 = new String(arr,0,3);//部分数组元素(下标含上不含下)转字符串，结果"hel"

2）字符串与byte数组的转换

String str1 = "hello";
byte [] arr = str1.getBytes();
String str2 = new String(arr);
String str3 = new String(arr,1,3);

3）charAt()

length()

indexOf()返回指定字符串的位置，如果不存在返回-1

trim()去掉左右空格

substring()一个参数表示该位置截取到末尾；两个参数表示从第一个参数截取到第二个参数（含上不含下）

split()按指定字符拆分字符串，拆分结果以数组形式返回

toUpperCase() / toLowerCase()

startWith() / endWith()

equalsIgnoreCase()不区分大小写进行字符串比较

replaceAll()两个参数，将第一个参数换成第二个

七、引用传递

画图分析，慢慢理解吧，总搞错

八、this&static

一、this：

1.调用本类属性

2.调用构造方法（注意： 1.this()只能放在构造方法首行。 2.程序中至少包括一个构造方法不使用this()调用其他构造方法，即避免递归调用。）

3.表示当前对象（常用于对象比较）

二、static

1.声明属性——全局属性/静态属性/类属性。全局属性是所有对象共享的。

调用：类名.static属性

2.声明方法——静态方法/类方法。非static方法可以调用static属性/方法，反之不行。

调用：类名.static方法名

九、代码块

1.普通代码块：{}括起的一块代码

2.构造块：直接写在类种的代码块

3.静态代码块：static声明的代码块

4.同步代码块：多线程涉及

执行时：

构造块 > 构造方法，且每次实例化对象都会执行构造块。

静态代码块 > main方法，且不管有多少个对象产生，静态代码块只执行一次。

十、构造方法私有化

类的封装体现在对属性和方法的封装，那么也就包括对构造方法的封装。如下：

class Demo {
    private Demo() {//封装构造方法
		
    };

    public void print() {
	System.out.println("Hello,World!");
    }
}

那我现在要使用这个Demo类，那就得先实例化一个Demo类的对象。正常实例化Demo类对象过程如下：

public class Test {
	public static void main(String[] args) {
		Demo d1 = new Demo();  //这行报错
		d1.print();
	}
}
	
class Demo {
	private Demo() {
		
	};

	public void print() {
		System.out.println("Hello,World!");
	}
}

此时new Demo（）时会报错，因为构造方法被私有化了，无法在外部访问。外部不行，那内部呢？来试试，如下：

class Demo {
	private Demo() {
		
	};

	public void print() {
		System.out.println("Hello,World!");
	}
	Demo d2 = new Demo();
}

可以！现在的情况是，在Demo类外部不可以直接实例化Demo对象，那么我们就在内部实例化，然后在Demo外部直接使用已经在内部实例化好了的对象。那么问题来了，怎么用上述的d2呢？

之前说过，用static修饰的属性可以由类名.属性名直接调用，因此我们可以将d2用static修饰，如下：

public class Test {
	public static void main(String[] args) {
		Demo d1 = Demo.d2;
		d1.print();
	}
}
	
class Demo {
	private Demo() {
		
	};

	public void print() {
		System.out.println("Hello,World!");
	}
	
	static Demo d2 = new Demo();
}

此时程序正常，运行之后输出：“hello，world！”

可是对一个类进行封装，应该将其所有属性都封装，包括d2，因此代码应该改为如下：

public class Test {
	public static void main(String[] args) {
		Demo d1 = Demo.d2; //编译报错，提示：1.改d2的权限修饰符 
                                                  //2.给d2加get/set方法
		d1.print();
	}
}
	
class Demo {
	private Demo() {
		
	};

	public void print() {
		System.out.println("Hello,World!");
	}
	
	private static Demo d2 = new Demo();
}

此时，d2被封装了，那想用被封装的属性，就得给它加上get/set方法，然后通过get方法获得。

又因为我们要在main方法中调用这个get方法，main方法是静态的，那get方法肯定也得是静态的，如下：

public class Test {
	public static void main(String[] args) {
		Demo d1 = Demo.getD2();//通过get调用d2，用来给d1赋值
                Demo d3 = Demo.getD2();
                Demo d4 = Demo.getD2();
		d1.print(); //d1就可以调用print方法啦
                d4.print(); //d1就可以调用print方法啦
                d3.print(); //d1就可以调用print方法啦
	}
}
	
class Demo {
	private Demo() {
		
	};

	public void print() {
		System.out.println("Hello,World!");
	}
	
	private static Demo d2 = new Demo();
	
	public static  Demo getD2() {
		return d2;
	}

	public  void setD2(Demo d2) {
		Demo.d2 = d2;
	}
}

十一、程序的意义

如上，虽然我们声明了d1,d3,d4三个对象，但是其本质都是引用d2，也就是说，不管外部怎么本质上也就只有一个实例化对象在。

在设计模式中，将其称为——单例设计模式。

现在先记一句话：只要将构造方法私有化，就可以控制实例化对象的产生。在后面学习类库的时候会进一步学到单例模式在Java中的应用。

十二、对象数组

对象数组：元素是对象的数组。因为数组必须先开辟空间，又是引用数据类型，所以声明时，所有元素都是null。因此要注意，在使用对象数组前，一定要给每个对象进行实例化。

1.声明：类名数组名[ ] = new 类[长度]；

2.范例：

class Demo {
	//私有化属性
	private String name; 
	//getter方法
	public String getName() { 
		return name;
	}
	//setter方法
	public void setName(String name) {
		this.name = name;
	}
	//构造器
	public Demo(String n) {
		this.name = n;
	}
}

public class Test {
	public static void main(String[] args) {
		Demo arr[] = new Demo[3];
		System.out.println("实例化数组对象前：");
		for(Demo a: arr) {
			System.out.println(a);//这里要是写成 a.getName(),运行时会报空指针异常。
		}
		//给数组对象实例化
		arr[0] = new Demo("张三");
		arr[1] = new Demo("李四");
		arr[2] = new Demo("王五");
		System.out.println("实例化数组对象后：");
		for(Demo a: arr) {
			System.out.println(a.getName());
		}
	}
}

十三、内部类

1.基本定义：

在类Outer里定义一个Inner类，则Inner称为内部类，Outer称为外部类。

2.内部类的优点：

可以方便的访问外部类中的私有属性。（不然的话得通过getter方法访问）

class Demo {
	//外部类的私有化属性
	private String info = "hello,world!"; 
	//外部类的公共方法
	public void fun() {
		new Inner().print();//外部类调用内部类的公共方法
	}
	//内部类
	class Inner{
		//内部类的公共方法
		public void print() {
			System.out.println(info);//内部类使用外部类的私有属性
		}
	}
}

public class Test {
	public static void main(String[] args) {
		new Demo().fun();

                //以下是 在外部访问内部类的格式
                Demo.Inner inn = new Demo.Inner();
                inn.print();
	}
}

3.使用static定义内部类：

static修饰得内部类只能访问static修饰的外部类属性或方法。

4.外部访问内部类：

外部类.内部类内部类对象 = new 外部类.内部类( ) ；

5.在方法中定义内部类：

1.8版本之前，方法中的内部类要是想访问方法的参数，参数前必须用final修饰。1.8版本之后不加final也行。

十四、单向链表实现

1、单向链表简单实现并打印：

public class Test {
	
	public static void main(String[] args) {
	Node node1 = new Node("aaa");
	Node node2 = new Node("bbb");
	Node node3 = new Node("ccc");
	Node node4 = new Node("ddd");
	node1.setNextNode(node2);
	node2.setNextNode(node3);
	node3.setNextNode(node4);
	node1.print(node1);
	}
}


class Node{
	private String data;
	private Node  nextNode;
	public Node(String data) {
		this.data = data;
	}
	public String getData() {
		return data;
	}
	public Node getNextNode() {
		return nextNode;
	}
	public void setNextNode(Node nextNode) {
		this.nextNode = nextNode;
	}
	
	public void print(Node node) {
		System.out.println(node.getData());
		if(node.getNextNode() !=null) {
			print(node.getNextNode());
		}
	}
}