Java 基础知识点 笔记总结

Posted 2021-10-19 IT_Holmes

文章目录

• 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(关于JAVA 反射 基础知识/编码经验的一些总结

 关于JAVA 异常 基础知识/编码经验的一些总结
 关于JAVA 反射 基础知识/编码经验的一些总结
 关于JAVA 异常 基础知识/编码经验的一些总结
 Java 基础知识点 笔记总结
 Java 基础知识点 笔记总结