Java学习笔记

最新推荐文章于 2023-05-16 16:14:59 发布

「已注销」

最新推荐文章于 2023-05-16 16:14:59 发布

阅读量154

点赞数

分类专栏：后端文章标签： java

本文链接：https://blog.csdn.net/qq_50363430/article/details/112756407

版权

后端专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Java学习笔记

在这里插入图片描述

JVM，JRE，JDk

JVM：保证Java语言跨平台
JRE：Java程序的运行环境
JDK：Java程序的开发环境

在这里插入图片描述

标识符

(1)就是给类，接口，方法，变量等起名字的字符序列
(2)组成规则：
A:英文大小写字母
B:数字
C:$和_
(3)注意事项：
A:不能以数字开头
B:不能是java中的关键字
C:区分大小写
(4)常见的命名规则(见名知意)
A:包全部小写
单级包：小写
举例：liuyi,com
多级包：小写，并用.隔开
举例：cn.itcast, com.baidu
B:类或者接口
一个单词：首字母大写
举例：Student,Demo
多个单词：每个单词首字母大写
举例：HelloWorld,StudentName
C:方法或者变量
一个单词：首字母小写
举例：name,main
多个单词：从第二个单词开始，每个单词首字母大写
举例：studentAge,showAllNames()
D:常量
全部大写
一个单词：大写
举例：PI
多个单词：大写，并用_隔开
举例：STUDENT_MAX_AGE

数据类型

在这里插入图片描述
A:整数占用字节数
byte 1
short 2
int 4
long 8
B:浮点数
float 4
double 8
C:字符
char 2
D:布尔
boolean 1
注意：
整数默认是int类型，浮点数默认是double。

长整数要加L或者l。（建议L，l像1）

单精度的浮点数要加F或者f。（同理，建议F）

数组的常见操作

	A:遍历
		方式1：
			public static void printArray(int[] arr) {
				for(int x=0; x<arr.length; x++) {
					System.out.println(arr[x]);
				}
			}
			
		方式2：
			public static void printArray(int[] arr) {
				System.out.print("[");
				for(int x=0; x<arr.length; x++) {
					if(x == arr.length-1) {
						System.out.println(arr[x]+"]");
					}else {
						System.out.println(arr[x]+", ");
					}
				}
			}
	B:最值
		最大值：
			public static int getMax(int[] arr) {
				int max = arr[0]; 
				
				for(int x=1; x<arr.length; x++) {
					if(arr[x] > max) {
						max = arr[x];
					}
				}
				
				return max;
			}
			
		最小值：
			public static int getMin(int[] arr) {
				int min = arr[0];
				
				for(int x=1; x<arr.length; x++) {
					if(arr[x] < min) {
						min = arr[x];
					}
				}
				
				return min;
			}
	C:逆序
		方式1：
			public static void reverse(int[] arr) {
				for(int x=0; x<arr.length/2; x++) {
					int temp = arr[x];
					arr[x] = arr[arr.length-1-x];
					arr[arr.length-1-x] = temp;
				}
			}
			
		方式2：
			public static void reverse(int[] arr) {
				for(int start=0,end=arr.length-1; start<=end; start++,end--) {
					int temp = arr[start];
					arr[start] = arr[end];
					arr[end] = temp;
				}
			}
	D:查表
			public static String getString(String[] strArray,int index) {
				return strArray[index];
			}
	E:基本查找
		方式1：
			public static int getIndex(int[] arr,int value) {
				for(int x=0; x<arr.length; x++) {
					if(arr[x] == value) {
						return x;
					}
				}
				
				return -1;
			}
			
		方式2：
			public static int getIndex(int[] arr,int value) {
				int index = -1;
			
				for(int x=0; x<arr.length; x++) {
					if(arr[x] == value) {
						index = x;
						break;
					}
				}
				
				return index;
			}

Java二维数组

在这里插入图片描述

二维数组中的一维数组的元素可以不相同

int[][] arr = new int [m][];
arr[0] = new int [3];
arr[1] = new int [4];

在这里插入图片描述

参数传递问题

Java中的参数传递问题
Java中只有值传递。
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数

类与对象

A:现实世界的事物
属性事物的基本描述（姓名，性别，年龄）
行为事物的功能（能做什么）
B:Java语言中最基本的单位是类。所以，我们要用类来体现事物
C:类
成员变量 - - 事物属性
成员方法 - - 事物行为
D:类：是一组相关的属性和行为的集合。是一个抽象的概念。
对象：是该类事物的具体存在，是一个具体的实例。(对象)

Java程序的开发，设计和特征

A:开发：就是不断的创建对象，通过对象调用功能
B:设计：就是管理和维护对象间的关系
C:特征
a:封装
b:继承
c:多态

成员变量和局部变量的区别

(1)在类中的位置不同
成员变量：类中方法外
局部变量：方法定义中或者方法声明上
(2)在内存中的位置不同
成员变量：在堆中
局部变量：在栈中
(3)生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
(4)初始化值不同
成员变量：有默认值
局部变量：没有默认值，必须定义，赋值，然后才能使用

匿名对象

(1)没有名字的对象
(2)应用场景
A:调用方法，仅仅只调用一次的时候。

调用完毕就是垃圾，可以被回收

多次调用其实是创建了一个新的对象。

b:可以作为实际参数传递。

封装

(1)隐藏实现细节，提供公共的访问方式
(2)好处：
A:隐藏实现细节，提供公共的访问方式
B:提高代码的复用性
C:提高代码的安全性
(3)设计原则
把不想让外界知道的实现细节给隐藏起来，提供公共的访问方式
(4)private是封装的一种体现。
封装：类，方法，private修饰成员变量，只能在本类中访问

private关键字

(1)私有的意义，可以修饰成员变量和成员方法
(2)特点：
被private修饰的后的成员只能在本类中被访问
(3)private的应用：
以后再写一个类的时候：
把所有的成员变量给private了
提供对应的getXxx()/setXxx()方法

this关键字

(1)代表当前类的引用对象
记住：哪个对象调用方法，该方法内部的this就代表那个对象
(2)this的应用场景：
A:解决了局部变量隐藏成员变量的问题
B:其实this还有其他的应用，明天讲解。

构造方法

(1)作用：用于对对象的数据进行初始化
(2)格式：
A:方法名和类名相同
B:没有返回值类型，连void都不能有
C:没有返回值
思考题：构造方法中可不可以有return语句呢?
可以。而是我们写成这个样子就OK了：return;
其实，在任何的void类型的方法的最后你都可以写上：return;
(3)构造方法的注意事项
A:如果我们没写构造方法，系统将提供一个默认的无参构造方法
B:如果我们给出了构造方法，系统将不再提供默认构造方法
如果这个时候，我们要使用无参构造方法，就必须自己给出。
推荐：永远手动自己给出无参构造方法。

构造方法在实例化对象（new）的时候只调用一次，而普通方法是在实例化对象之后可以随意调用多次。

	标准案例
	class Student {
		private String name;
		private int age;
	public Student(){}
	
	public Student(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public int getAge() {
		return age;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
}

测试：
class StudentDemo {
	public static void main(String[] args) {
		//方式1
		Student s1 = new Student();
		s1.setName("赵四");
		s1.setAge(34);
		System.out.println(s1.getName()+"---"+s1.getAge());
		
		//方式2
		Student s2 = new Student("刘波",37);
		System.out.println(s2.getName()+"---"+s2.getAge());
	}
}

继承

(1)把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系，
这多个类就具备了这些内容。这个关系叫继承。
(2)Java中如何表示继承呢?格式是什么呢?
A:用关键字extends表示
B:格式：
class 子类名 extends 父类名 {}
(3)继承的好处：
A:提高了代码的复用性
B:提高了代码的维护性
C:让类与类产生了一个关系，是多态的前提
(4)继承的弊端：
A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。
原则：低耦合，高内聚。
耦合：类与类的关系
内聚：自己完成某件事情的能力
B:打破了封装性
(5)Java中继承的特点
A:Java中类只支持单继承
B:Java中可以多层(重)继承(继承体系)
(6)继承的注意事项：
A:子类不能继承父类的私有成员
B:子类不能继承父类的构造方法，但是可以通过super去访问
C:不要为了部分功能而去继承
(7)什么时候使用继承呢?
A:继承体现的是：is a的关系。
B:采用假设法
(8)Java继承中的成员关系
A:成员变量
a:子类的成员变量名称和父类中的成员变量名称不一样，这个太简单
b:子类的成员变量名称和父类中的成员变量名称一样，这个怎么访问呢?
子类的方法访问变量的查找顺序：
在子类方法的局部范围找，有就使用。
在子类的成员范围找，有就使用。
在父类的成员范围找，有就使用。
找不到，就报错。
B:构造方法
a:子类的构造方法默认会去访问父类的无参构造方法
是为了子类访问父类数据的初始化
b:父类中如果没有无参构造方法，怎么办?
子类通过super去明确调用带参构造
子类通过this调用本身的其他构造，但是一定会有一个去访问了父类的构造
让父类提供无参构造（推荐）
C:成员方法
a:子类的成员方法和父类中的成员方法名称不一样，这个太简单
b:子类的成员方法和父类中的成员方法名称一样，这个怎么访问呢?
通过子类对象访问一个方法的查找顺序：
在子类中找，有就使用
在父类中找，有就使用
找不到，就报错

子类的重写方法权限不能比父类低

多态

a:具体类多态
class Fu {}
class Zi extends Fu {}
	Fu f = new Zi();
b:抽象类多态
	abstract class Fu {}
	class Zi extends Fu {}
	
	Fu f = new Zi();
c:接口多态
	interface Fu {}
	class Zi implements Fu {}
	
	Fu f = new Zi();

(3)多态中的成员访问特点
A:成员变量
编译看左边，运行看左边
B:构造方法
子类的构造都会默认访问父类构造
C:成员方法
编译看左边，运行看右边
D:静态方法
编译看左边，运行看左边

(4)多态的好处：
A:提高代码的维护性(继承体现)
B:提高代码的扩展性(多态体现)
(5)多态的弊端：
父不能使用子的特有功能。

子可以当父用，因为继承了父的所有方法（部分重写），父不能当子用，因为子有拓展方法

抽象类

(1)把多个共性的东西提取到一个类中，这是继承的做法。
但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体。
也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。
所以，我们在定义这些共性的方法的时候，就不能给出具体的方法体。
而一个没有具体的方法体的方法是抽象的方法。
在一个类中如果有抽象方法，该类必须定义为抽象类。
(2)抽象类的特点
A:抽象类和抽象方法必须用关键字abstract修饰
B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类
C:抽象类不能实例化
D:抽象类的子类
a:是一个抽象类。
b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。
(3)抽象类的成员特点：
A:成员变量
有变量，有常量
B:构造方法
有构造方法
C:成员方法
有抽象，有非抽象

内部类(理解)
(1)把类定义在另一个类的内部，该类就被称为内部类。
举例：把类B定义在类A中，类B就被称为内部类。
(2)内部类的访问规则
A:可以直接访问外部类的成员，包括私有
B:外部类要想访问内部类成员，必须创建对象
(3)内部类的分类
A:成员内部类
B:局部内部类
(4)成员内部类
A:private 为了数据的安全性
B:static 为了访问的方便性
成员内部类不是静态的：
外部类名.内部类名对象名 = new 外部类名.new 内部类名();
成员内部类是静态的：
外部类名.内部类名对象名 = new 外部类名.内部类名();

(5)成员内部类的面试题
	30,20,10
	
	class Outer {
		public int num = 10;
		
		class Inner {
			public int num = 20;
			
			public viod show() {
				int num  = 30;
		
				System.out.println(num);
				System.out.println(this.num);
				System.out.println(Outer.this.num);
			}
		}
	}
(6)局部内部类
	A:局部内部类访问局部变量必须加final修饰。
	B:为什么呢?
		因为局部变量使用完毕就消失，而堆内存的数据并不会立即消失。
		所以，堆内存还是用该变量，而改变量已经没有了。
		为了让该值还存在，就加final修饰。
		通过反编译工具我们看到了，加入final后，堆内存直接存储的是值，而不是变量名。
(7)匿名内部类
	A:是局部内部类的简化形式
	B:前提
		存在一个类或者接口
	C:格式:
		new 类名或者接口名() {
			重写方法;
		}
	D:本质：
		其实是继承该类或者实现接口的子类匿名对象
(8)匿名内部类在开发中的使用
	我们在开发的时候，会看到抽象类，或者接口作为参数。
	而这个时候，我们知道实际需要的是一个子类对象。
	如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。
	interface Person {
		public abstract void study();
	}
	
	class PersonDemo {
		public void method(Person p) {
			p.study();
		}
	}
	
	class PersonTest {
		public static void main(String[] args) {
			PersonDemo pd = new PersonDemo();
			pd.method(new Person() {
				public void study() {
					System.out.println("好好学习，天天向上");
				}
			});
		}
	}
	
(9)匿名内部类
	interface Inter {
		void show();
	}
	
	class Outer {
		//补齐代码
		public static Inter method() {
			return new Inter() {
				public void show() {
					System.out.println("HelloWorld");
				}	
			};
		}
	}
	
	class OuterDemo {
		public static void main(String[] args) {
			Outer.method().show(); //"HelloWorld"
		}
	}

通配符

当需要模糊搜索或对文件执行操作时，可用*表示字符串，？表示单个字符。例，现有javadfjsk，javad，javac，javacjiow，若搜索java * ，则会查找到javadfjsk，javad，javac，javacjiow。若搜索java？，则会查找到javad，javac。

深克隆和浅克隆

（b = a.clone()）对于基本类型无区别，对于引用类型，浅克隆不会克隆一个新的对象而是与a引用同一个对象，也就是通过b修改某引用类型的值会导致a中引用类型同时发生变化。深克隆会克隆一个新的引用对象，也就是通过b修改某引用类型的值不会导致a中引用类型发生变化。

不要编写返回可变对象引用的访问器方法

Static

1.静态字段

也称为类字段，即使没有对象，类字段也存在。术语“静态”只是延续了c++的叫法，并无实际意义。

2.静态方法

不在对象上执行，可以认为静态方法是没有this参数的方法

原生方法

原生方法可以绕过Java语言的访问控制机制

对象引用是按值传递的

方法不能修改基本数据类型的参数

方法可以改变对象参数的状态

方法不能让一个对象参数引用一个新的对象

调用构造器的具体处理步骤

1.如果构造器的第一行调用了另一个构造器，则根据所提供的参数执行第二个构造器

2.否则，

a）所有数据字段初始化为其默认值

b）按照在类声明中出现的顺序。执行所有字段初始化方法和初始化块

3.执行构造器主体代码

类的设计技巧

1，一定要保证数据私有

2，一定要对数据进行初始化

3，不要在类中使用过多的基本类型，使用其他的类去替换多个相关的基本类型

4，不是所有的字段都需要单独的访问器和更改器

5，分解有过多职责的类

6，类名和方法名要能够体现它们的职责

7，优先使用不可改变的类；类似plusDays不是修改对象而是返回一个状态已经更改的对象

子类构造器

使用super调用构造器的语句必须是子类构造器的第一条语句

如果子类未显式调用超类的构造器，则自动调用超类的无参构造器

多态

一个对象变量可以指示多种实际类型的现象被称为多态，在运行时能够自动选择恰当的方法，称为动态绑定。

签名

方法的名字和参数列表称为方法的签名。返回类型不是签名的一部分，但在override一个方法时，需要保证返回类型的兼容性，允许子类将override方法的返回类型改为原返回类型的子类型（可协变的返回类型）。

java核心技术Ⅰ P164

final

不允许扩展的类被称为finl类。final类中的方法自动成为final方法（子类不能overri这个方法），而不包括字段。对于final字段来说，构造对象之后就不允许改变他们的值了。

内联

如果一个方法没有被覆盖而且很短，编译器就能对它进行优化处理。例如，e.getName()会被替换为访问字段 e.name。

强制类型转换

1.只能在继承层次内进行强制类型转换

2.将超类强制转换为子类之前，应该使用instanceof进行检查

hashCode

散列码是对象到处的一个整型值。

String类使用以下算法得到散列码

int hash=0;
for (int i=0; i<length(); i++) {
    hash = hash*31 + charAt(i);
}

Object类的默认hashCode方法会从对象的存储地址得出散列码

继承的设计技巧

1.将公共字段和操作放在超类中

2.不要使用受保护的字段

3.使用继承实现is a关系

4.除非所有继承的方法都有意义，否则不要使用继承

5.在覆盖方法时，不要改变预期的行为

6.使用多态，而不要使用类型信息

7.不要滥用反射

接口

接口描述类应该做什么，而不指定它们具体如何做

接口字段被标记为public static final

在这里插入图片描述

「已注销」

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习笔记

Java学习笔记JVM，JRE，JDk JVM：保证Java语言跨平台 JRE：Java程序的运行环境 JDK：Java程序的开发环境标识符 (1)就是给类，接口，方法，变量等起名字的字符序列 (2)组成规则： A:英文大小写字母 B:数字 C:$和_ (3)注意事项： A:不能以数字开头 B:不能是java中的关键字 C:区分大小写 (4)常见的命名规则(见名知意) A:包全部小写单级包：小写
复制链接

扫一扫