Java 基础知识点笔记总结 (四)

文章目录

1. 面向对象
- 1.1 类和实例
- 1.2 类的属性和方法
- 1.3 对象的内存解析
- 1.4 对象数组
- 1.5 匿名对象
- 1.6 方法重载(overload) loading...
- 1.7 可变个数形参
- 1.8 值传递的注意细节
- 1.9 递归(recursion)方法
2. 面向对象封装隐藏
3. 构造器(构造方法，constructor)
4. JavaBean 概念
5. UML类图
6. this关键字
7. Package 和 import
8. MVC 设计模式
9. eclipse 快捷键
10. 面向对象继承性
11. Debug 操作
12. 重写
13. super 方法
14. 对象的多态性
15. instanceof 操作符
16. Object类使用
17. == 和 equals() 区别
18. Object类中的 toString()方法
19. @Test 单元测试方法
20. 包装类(Wrapper)
- 20.1 类的基本数据类型 ⇒ 转换为包装类(通过，调用包装类的构造器)
- 20.2 包装类 ⇒ 转换为基本数据类型(调用包装类的xxxValue()，xxx看数据类型)
- 20.3 自动装箱和自动拆箱
- 20.4 基本数据类型，包装类 ⇒ String类型(调用String 重载的valueOf(xxx))
- 20.5 String类型 ⇒ 基本数据类型，包装类(调用包装类的parseXxx())
- 20.6 三元运算符的两个结果类型必须统一！！！

1. 面向对象 1.1 类和实例

1.2 类的属性和方法

通过对象.属性或对象.方法调用对象的结构。

1.3 对象的内存解析

注意：存放在Heap内的属性都是非static，static的都存放到方法区，因此方法区也叫静态区。

大体过程如下：

1.4 对象数组

public class HelloWorld {
	public static void main(String[] args) {
		Student[] stus = new Student[5];
		
		stus[0] = new Student(); 
		
		System.out.println(stus[0]); //声明定义后得到的是地址
		System.out.println(stus[1]); //没有定义为null
	}
}

class Student{
	int number;
	int state = 1;
	int score;
}

对象数组的内存解析：

1.5 匿名对象

public class HelloWorld {
	public static void main(String[] args) {
		Phone p = new Phone();
		System.out.println(p);
		
		p.sendEmail();
		p.playGame("lol");
		
		//匿名对象 ,就是没有名字的调用 ，注意这里两个new不是相同的！
		new Phone().playGame("英雄联盟1");;
		new Phone().playGame("英雄联盟2");
		//匿名对象特点就是只能调用一次。
	}
}

class Phone{
	double price;
	
	public void sendEmail() {
		System.out.println("发送邮件");
	}
	public void playGame(String s) {
		System.out.println("玩游戏 " + s);
	}
}

1.6 方法重载(overload) loading…

定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
·
记住对于方法重载一定看参数个数和类型，和对应返回值什么的无关！！

package com.holmes.contact;

public class ArrayUtil {
	//一个参数
	public int OverLoad(int i) {
		return i;
	}
	//没有参数
	public double OverLoad() {
		return 0;
	}
}

1.7 可变个数形参

package com.holmes.contact;

import java.util.Arrays;

public class ArrayUtil {
	
	public static void main(String[] args) {
		
		ArrayUtil arr = new ArrayUtil();
		
		arr.show("1","2","3");
	}
	//使用...接受不确定参数，像一个数组形参
	public void show(String... str) {
		System.out.println(Arrays.toString(str));
	}
	
}

1.8 值传递的注意细节

正常值传递，就像下面调用了函数swap，也并没有交换数值。可以理解为仅仅只是交换了形参，没有交换实参，实际上就是一个栈的先进先出的问题。

package com.holmes.contact;

import java.util.Arrays;

public class ArrayUtil {
	
	public static void main(String[] args) {
		int m = 11;
		int n = 22;
		ArrayUtil arr = new ArrayUtil();
		
		System.out.println("m = "+ m +", n = "+ n);
		
		arr.swap(m,n);
		
		System.out.println("m = "+ m +", n = "+ n);
	}
	//使用...接受不确定参数，像一个数组形参
	public void swap(int m,int n) {
		int temp = m;
		m = n;
		n = temp;
	}
}
//m = 11, n = 22
//m = 11, n = 22

对象值传递，要注意的是对象是地址，正常数值是重新赋值(新地址)。因此，直接操作对象地址就是修改实参对象本身

package com.holmes.contact;

public class Test {
	
	public static void main(String[] args) {
		Test arr = new Test();
		arr.first();
		
		//这里注意的就是对象的值传递是传递的地址，因此在函数修改会修改对象的值。
		//15 0
		//20
	}
	
	public void first() {
		int i=5;
		Value v = new Value();
		v.i = 25;
		second(v,i);
		System.out.println(v.i);
	}
	
	public void second(Value v,int i) {
		i = 0;
		v.i = 20;
		Value val = new Value();
		v = val;
		System.out.println(v.i + " " + i);
	}
	
}

class Value{
	int i = 15;
}

那么如何想要正常值在被执行调用函数后，想要它的执行结果是函数的值呢？

方法一：
使用System.exit(0)退出程序。

package com.holmes.contact;

public class Test {
	
	public static void main(String[] args) {
		int a = 10;
		int b = 10;
		//这我像调用了method方法后，结果输出a的值为100，b的值为200.
		method(a,b);
		System.out.println("a = "+a);
		System.out.println("b = "+b);
	}
	
	public static void method(int a,int b) {
		a *= 10;
		b *= 20;
		System.out.println("a = "+a);
		System.out.println("b = "+b);
		System.exit(0);
	}
}

方法二：
重写println方法。

package com.holmes.contact;

import java.io.PrintStream;

public class Test {
	
	public static void main(String[] args) {
		int a = 10;
		int b = 10;
		//这我像调用了method方法后，结果输出a的值为100，b的值为200.
		method(a,b);
		System.out.println("a = "+a);
		System.out.println("b = "+b);
		
		//a = 100
		//b = 200
	}
	
	public static void method(int a,int b) {
		PrintStream ps = new PrintStream(System.out) {
			@Override
			public void println(String x) {
				if("a = 10".equals(x)) {
					x = "a = 100";
				}else if("b = 10".equals(x)){
					x = "b = 200";
				}
				super.println(x);
			}
		};
		System.setOut(ps);
		
	}
}

1.9 递归(recursion)方法

就是在函数中调用本身，依次递归的方法。

注意的是：有个别的可以做if判断。

package com.holmes.contact;

import java.io.PrintStream;
import java.util.Arrays;

public class Test {
	
	public static void main(String[] args) {
		System.out.println(f(10));
	}
	
	public static int f(int i) {
		if(i == 0) {
			return 1;
		}else if(i == 1) {
			return 4;
		}else {
			return 2*f(i-1)+f(i-2);
		}
	} 
}

2. 面向对象封装隐藏

面向对象三大特征：封装，继承，多态。

封装就是一个隐藏效果，封装好直接用的方法或者类。

四个访问修饰符：

为了封装效果，我们常常通过getxxx()和setxxx()来获取和设定属性值。

3. 构造器(构造方法，constructor)

package com.holmes.contact;

public class Test {
	
	public static void main(String[] args) {
		Person p = new Person();
		Person p1 = new Person(1,2);
		Person p2 = new Person("ab","cd");
		
		p.GetAbs();
		p1.GetAbs();
		p2.GetAbs();
	}
}

class Person{
	int a;
	int b;
	String str1 = "0";
	String str2 = "0";
	
	//以下就创建了几个不同参数和类型的构造器
	public Person() {
		this.a = 0;
		this.b = 0;
	}
	
	public Person(int a,int b) {
		this.a = a;
		this.b = b;
	}
	
	public Person(String str1,String str2) {
		this.str1 = str1;
		this.str2 = str2;
	}
	
	public void GetAbs() {
		System.out.println(a+","+b+","+str1+","+str2);
	}
}

4. JavaBean 概念

5. UML类图

6. this关键字

this最常用的作用就是区别形参和属性，不能混淆。

当然this也可以应用到调用函数中，其实this就可以理解为本类中的内容。

像this()，其实就是调用类本身的构造器(注意：在构造器中不能调用本身的构造器，可以调用其他构造器)，也可以加参数。

package com.holmes.contact;

public class Test {
	
	public static void main(String[] args) {
		Person p = new Person();
		p.eat();
	}
}

class Person{
	int a;
	int b;
	
	public Person() {
		this.a = 0;
		this.b = 0;
	}
	
	public void eat() {
		System.out.println("吃饭");
		//this应用到方法
		this.play();
	}
	
	public void play() {
		System.out.println("玩游戏");
	}
}

7. Package 和 import

Package就是包。

import导入：
注意：import导入的不是一个类！是类中的结构(方法，接口等等)。

全类名命名方式：

8. MVC 设计模式

9. eclipse 快捷键

10. 面向对象继承性

面向对象三大特征：封装，继承，多态。

一旦子类A继承了父类B以后，子类A就获取了父类B种声明的结构，属性，方法。

特别的，父类中声明为private的属性或方法，子类继承后，仍然认为获取了父类中私有的结构，但是因为封装性的影响，使得子类不可以直接调用父类的private结构而已！！！

子类继承父类以后，还可以声明自己特有的属性或方法，来实现别的功能。

如果我们没有显示声明一个类的父类的花，则此类默认继承了java.lang.Object类。

所有的java类(除java.lang.Object类之外)，都直接或间接的继承了java.lang.Object类！

也就是说，所有的java类具有java.lang.Object类声明的功能！！

11. Debug 操作

Debug通常遇到，没有报错，但是结果却是错误的。

设置多个断点

debug as java application

以下几个按钮对应上面的几个操作：

12. 重写

方法重写(override / overwrite):子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作。

子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符！

特殊情况：子类不能重写父类中声明为private权限的方法！！

返回值类型：
父类被重写的方法的返回值类型是void，则子类重写的方法返回值类型只能是void！！！
父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类。
父类被重写的方法的返回值类型是基本数据类型，则子类重写的方法的返回值类型必须是相同的基本数据类型。！

13. super 方法

如果this指的当前类，那么super就指的是父类。

super调用父类属性和方法：

super调用构造器：

14. 对象的多态性

父类的引用指向了子类的对象！！

虚拟方法调用：
当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法。

package com.itholmes.p2;

public class PersonTest {
	public static void main(String[] args) {
		
		//定义了Person类调用
		Person p1 = new Person();
		p1.eat();
		//定义了Man类调用
		Man man = new Man();
		man.eat();
		man.age = 25;
		//定义了Woman类调用
		Woman woman = new Woman();
		woman.eat();
		
		System.out.println("******************");
		
		//对象多态形式：父类的引用指向子类的对象
		Person p2 = new Man();
		//当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法。--虚拟方法调用 
		p2.eat();
		p2.walk();
		
		//earnMoney()没有在父类Person中定义，在子类Man中定义了。
		//p2中的earnMoney()方法就不能被调用了，因为Person中没有！！！
		//p2.earnMoney();
		
	}
}

多态性常用的情形：

package com.itholmes.p2;

public class Test {
	public static void main(String[] args) {
		Test t = new Test();
		
		//多态性操作
		t.func(new Dog());
		
	}
	//设置类对象为接受
	public void func(Animal animal) {
		animal.eat();
		animal.shout();
	}
}

class Animal{
	
	public void eat() {
		System.out.println("动物吃饭");
	}
	
	public void shout() {
		System.out.println("动物手套");
	}
}

class Dog extends Animal{
	@Override
	public void eat() {
		System.out.println("小狗吃饭");
	}
	@Override
	public void shout() {
		System.out.println("小狗手套");
	}
}

对象的多态性，只适用于方法，不适用于属性！我们如果定义了在子类和父类中定义了相同属性，调取时也仅仅调用了父类，也就是对于属性(编译和运行都看左边)。

package com.itholmes.p2;

public class Test {
	public static void main(String[] args) {
		Animal animal = new Dog();
		
		//运行也仅仅显示的是父类
		System.out.println(animal.age);
	
	}
	
}

class Animal{
	int age = 10;
}

class Dog extends Animal{
	int age = 20;
}

多态仅仅能够调用父类的方法和属性和子类重写的方法，
那么，如何调用子类特有的属性和方法？

向下转型：使用强制类型转换符号！！

package com.itholmes.p2;

public class Test {
	public static void main(String[] args) {
		Animal animal = new Dog();
		
		//对于属性运行也仅仅显示的是父类属性
		System.out.println(animal.age);
		
		//向下转型，强制转换
		Dog d = (Dog)animal;
		System.out.println(d.age);
	
	}
	
}

class Animal{
	int age = 10;
}

class Dog extends Animal{
	int age = 20;
}

15. instanceof 操作符

instanceof操作符：

package com.itholmes.p2;

public class Test {
	public static void main(String[] args) {
		Animal animal = new Dog();
		
		//对于属性运行也仅仅显示的是父类属性
		System.out.println(animal.age);
		
		//向下转型，强制转换
		Dog d = (Dog)animal;
		System.out.println(d.age);
		
		//这个时候的animal已经转为了Dog类型！！！
		System.out.println(animal instanceof Dog);
		
		//10
		//20
		//true
	}
	
}

class Animal{
	int age = 10;
}

class Dog extends Animal{
	int age = 20;
}

class monkey extends Animal{
	int age = 30;
}

alt + shift + s 快捷键，弹出源代码的相关选项，通常用来获取变量的get和set，构造器的方法。

16. Object类使用

Object类是所有Java类的根父类。

如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类。

getClass() :获取当前类名

getSuperclass() :获取当前父类名

package com.itholmes.p2;

public class Test {
	public static void main(String[] args) {
		Order order = new Order();
		//getClass()获取当前类名
		System.out.println(order.getClass());
		//getSuperclass()获取当前父类名
		System.out.println(order.getClass().getSuperclass());
		
		//class com.itholmes.p2.Order
		//class java.lang.Object
	}
	
}
class Order{
	
}

Object类中的clone()方法：复制类。

17. == 和 equals() 区别

== 作用：
比较基本数据变量数据是否相同。
比较引用数据类型变量，对象地址值是否相同。

equals()方法使用：
只能适用于引用数据类型。

18. Object类中的 toString()方法

注意和之前的Arrays.toString()方法不同！

一般我们定义的类：返回类的路径和类名 + @ + JVM虚拟地址。

像Integer这种包装类，使用toString()后，得到的是对应的基本数据类型(例如Integer对应int)。

package com.itholmes.p2;

public class test {
	
	public static void main(String[] args) {
		Tom t = new Tom();
		//当我们输出一个对象的引用时，实际上就是调用当前对象的toString()方法。
		System.out.println(t.toString());//com.itholmes.p2.Tom@5aaa6d82
		System.out.println(t);//com.itholmes.p2.Tom@5aaa6d82
	}
}

class Tom{
	
}

像toString这种方法完全可以ctrl + 左键，查看他的源码！

19. @Test 单元测试方法

注意权限public，没有返回值，没有形参。

package com.itholmes.p2;

import java.util.Date;

import org.junit.Test;

public class test {
	
	@Test
	public void testEquals() {
		String s1 = "MM";
		String s2 = "MM";
		System.out.println(s1.equals(s2));
		
		Object obj = new String("GG");
		Date date = (Date)obj;
	}
}

手动导入方法如下：

20. 包装类(Wrapper)

三者转换：基本数据类型，包装类，String。

20.1 类的基本数据类型 ⇒ 转换为包装类(通过，调用包装类的构造器)

integer类型转换注意事项：

package com.itholmes.p2;
import org.junit.Test;

public class test {
	
	//类的基本数据类型 ==》 转换为包装类(通过，调用包装类的构造器)
	@Test
	public void testEquals() {
		int num1 = 0;
		
		//基本数据类型变量无法直接使用toString类的方法
		//System.out.println(num1.toString());
		
		//但是如果是类对象转换就可以使用类方法。
		Integer in1 = new Integer(num1);
		System.out.println(in1.toString());
		
		//符合integer型的字符串形式可以
		Integer in2 = new Integer("123");
		System.out.println(in2.toString());
		
		//但是，不符合就会报错！！！
//		Integer in3 = new Integer("123abc");
//		System.out.println(in3.toString());
	
	
	}
}

boolean类型转换注意事项：

package com.itholmes.p2;
import org.junit.Test;

public class test {
	
	//类的基本数据类型 ==》 转换为包装类(通过，调用包装类的构造器)
	@Test
	public void testEquals() {
		
		Boolean b1 = new Boolean(true);
		Boolean b2 = new Boolean("true");
		Boolean b3 = new Boolean("true123");
		
		System.out.println(b3);
		//注意boolean比较特殊输入别的字符串，默认为false
		//具体可以再查看已下boolean判断的源码
	}
}

20.2 包装类 ⇒ 转换为基本数据类型(调用包装类的xxxValue()，xxx看数据类型)

package com.itholmes.p2;
import org.junit.Test;

public class test {
	
	//包装类 ⇒  转换为基本数据类型(调用包装类的xxxValue()，xxx看数据类型)
	@Test
	public void test2() {
		
		//int类型
		Integer in1 = new Integer(12);
		
		int i1 = in1.intValue();
		
		System.out.println(i1);
		
		//float类型
		Float fl1 = new Float(1.1);
		
		float f1 = fl1.floatValue();
		
		System.out.println(f1);
		
	}
}

20.3 自动装箱和自动拆箱

自动装箱实际就是基本数据类型转为包装类.

自动拆箱实际上是包装类转为基本数据类型

package com.itholmes.p2;
import org.junit.Test;

public class test {
	
	//自动装箱实际就是基本数据类型 转为 包装类
	//自动装箱,像下面基本数据类型直接赋值给了对象，就是自动装箱。
	//int num2 = 10;
	//Integer In2 = num2;
	
	//自动拆箱实际上是包装类 转为 基本数据类型
	//Integer i = new Integer(123);
	//System.out.println(i.toString());
	
	
	@Test
	public void test2() {
		
		int num1 = 10;
		
		//这里num1是基本数据类型，然而这里参数要传递一个对象！显然不可以！！
		//但是再java 5.0 新特性后，就补充了自动装箱，从而满足了Object obj = num1;这样的例子。
		method(num1);
		
		
	}
	
	public void method(Object obj) {
		System.out.println(obj);
	}
}

20.4 基本数据类型，包装类 ⇒ String类型(调用String 重载的valueOf(xxx))

方式1：连接运算

方式2：String.valueOf(xxx),调用String中的valueOf转换为字符串

package com.itholmes.p2;
import org.junit.Test;

public class test {
	
	@Test
	public void test2() {
		
		int num1 = 10;
		
		//方式1：连接运算
		String str = num1 + "";
		
		//方式2：String.valueOf(xxx),调用String中的valueOf转换为字符串
		float f1 = 12.3f;
		String str2 = String.valueOf(f1);
		System.out.println(str2);
		
		
	}
	
}

20.5 String类型 ⇒ 基本数据类型，包装类(调用包装类的parseXxx())

注意：首先，强转是不可以的！！！原因：强转没有子父类关系的，是不能被强转。

String类型 ⇒ 基本数据类型，包装类(调用包装类的parseXxx())

package com.itholmes.p2;
import org.junit.Test;

public class test {
	
	@Test
	public void test2() {
		
		String str1 = "123";
		
		//首先，强转是不可以的！！！ 原因：强转没有子父类关系的，是不能被强转。
		//int num1 = (int)str1;
		//Integer in1 = (Integer)str1;
		
		//String类型 ⇒ 基本数据类型，包装类(调用包装类的parseXxx())
		int num2 = Integer.parseInt(str1);
		System.out.println(num2);
		
		String str2 = "true";
		boolean b1 = Boolean.parseBoolean(str2);
		System.out.println(b1);
		
		//需要注意的hi是NumberFormatException错误，例如把一个abc转为Integer类型，那肯定格式错误！
	}
	
}

20.6 三元运算符的两个结果类型必须统一！！！

package com.itholmes.p2;
import org.junit.Test;

public class test {
	
	@Test
	public void test2() {
		
		Object o1 = true ? new Integer(1) : new Double(2.0);
		System.out.println(o1);
		
		//结果为：1.0。
		//为什么不是1呢？因为三元运算符的两个结果必须统一为一个类型.
		//当然Integer和Double比起来，自然是将Integer提升为了Double类型了。
		System.out.println(o1 instanceof Double);
		System.out.println(o1 instanceof Integer);
	}
	
}

注意：转换时，可能会报NumberFormatException这种错误，要记住。

Java 基础知识点 笔记总结 (四)

Java相关栏目本月热门文章

Java 基础知识点笔记总结 (四)