java学习笔记一（2021.11.02）_随笔

java学习笔记一（2021.11.02）

java学习笔记整理

一、JVM 、JDK、JRE:
二、java和C++的区别:
三、字符型常量和字符串常量区别：
四、自增自减运算符：++ && -- :
五、continue、break和return的区别：
六、泛型：

一、JVM 、JDK、JRE:

1. JVM: java虚拟机是运行Java字节码（扩展名为.class文件）的虚拟机

2. JDK: java SDK,拥有JRE的一切，还有编译器（javac）和工具（如javadoc和jdb）。它能够创建和编译程序。

3. JRE: 是java运行时环境，它运行已编译java程序所需的所有内容的集合，包括Java虚拟机（JVM），java类库，java命令和其他的一些基础构件。

Java是编译和解释共存的语言： java先由编译器编译成.class类型的文件，然后通过虚拟机（JVM）从.class文件中读一行解释执行一行。

二、java和C++的区别:

1. 区别：

都是都是面向对象的语言，支持封装、继承、多态
java不提供指针来直接访问内存，程序内存更加安全
java的类是单继承的，C++支持多重继承，虽然java的类不可以多继承，但是接口可以多继承
java有自动内存管理垃圾回收机制（GC），不需要程序员手动释放无用内存
C++同时支持方法重载和 *** 作符重载，但是java只支持方法重载。

封装性：指隐藏对象的属性和实现细节，仅对外提供公共访问公式
实现java封装：

java中通过将数据声明为私有（private）的，再提供公共（public）的方法：getXXX()和setXXX()实现对该属性的 *** 作，以实现下述目的：

1）隐藏一个类中不需要对外提供的实现细节；

2）使用者只能通过事先制定好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理 *** 作；

3）便于修改，增强代码的可以维护性；

三、字符型常量和字符串常量区别：

1. 字符型常量是单引号引起的字符：‘A’，字符串常量是双引号引起的0个或若干个字符。

2. 含义：字符型常量相当于一个整型值（ASCII值），可以参加表达式运算；字符串常量代表一个地址值(该字符串再内存中存放位置）
3. 占内存大小：字符常量只占两个字节；字符串常量占若干个字节（注意：char在java中占两个字节）

四、自增自减运算符：++ && – :

当运算符放在变量之前时：++a && --a 先自增、减，再赋值。

当运算符放在变量之后时：a++ && a-- 先赋值，再自增、减。

五、continue、break和return的区别：

continue：指跳出当前这一循环，继续下一个循环
break：指跳出整个循环体，继续执行循环下面的语句

return用于跳出所在方法，结束该方法的运行：
1. return：直接使用return方法执行，用于没有返回值函数的方法
2. return value：return一个特定值，用于有返回值函数的方法。

六、泛型：

和class的使用

泛型类的定义：

class Point{
	
	private T x;
	private T y;
	
	public void setX(T x){ //作为参数
		this.x = x;
	}
	
	public void setY(T y) {
		this.y = y;
	}
	
	public T getX() {  //作为返回值
		return this.x;
	}
	
	public T getY() {
		return this.y;
	}
	
}

public class Genericity {

	public static void main(String[] args) {
		
		//IntegerPoint使用
		Point p = new Point();	//构造实例
		p.setX(new Integer(100));
		System.out.println(p.getX());		//100
		
		
		//floatPoint使用
		Point f = new Point();
		f.setX(new Float(10.12f));
		System.out.println(f.getX());    //10.12
		
		//StringPoint使用
		Point s = new Point();
		s.setX(new String("LONG"));
		System.out.println(s.getX());  //LONG
	}
}

这个T表示派生自Object类的任何类，比如String、Integer、Double等等，

多泛型定义：

//多泛型定义
class MorePoint{
	private T x;
	private T y;
	
	private U name;
	
	public void setX(T x) {
		this.x = x;
	}
	
	public T getX() {
		return this.x;
	}
	
	public void setY(T y) {
		this.y = y;
	}
	
	public T getY() {
		return this.y;
	}
	
	public void setName(U name) {
		this.name = name;
	}
	
	public U getName() {
		return this.name;
	}
}

//多泛型的使用
		MorePoint morePoint = new MorePoint();
		morePoint.setName("多泛型");
		System.out.println("morPont.getName:" + morePoint.getName());

泛型接口定义及使用：

3.1 使用方法一：非泛型类

要清楚的一点是Generic不是一个泛型类！因为他类名后没有！

interface Info{  //在接口上定义泛型
	
	public T getVar();// 定义抽象方法，抽象方法的返回值就是泛型类型
	
	public void setVar(T x);
}
class Generic implements Info{
	private String var;
	
	public Generic(String Var) {
		this.setVar(Var);
	}
	
	
	@Override
	public void setVar(String var) {
		this.var = var;
	}
	@Override
	public String getVar() {
		return this.var;
	}
}

public class InfoImpl  {

	public static void main(String[] args) {
		Generic i = new Generic("接口泛型");
		System.out.println(i.getVar());
		
	}
}

3.2 使用方法二：泛型类：

在方法一中，我们在类中直接把Info接口给填充好了，但我们的类，是可以构造成泛型类的，那我们利用泛型类来构造填充泛型接口会是怎样呢？

class Generic1 implements Info{  //定义泛型接口的子类
	private T var;
	public Generic1(T Var) {
		this.setVar(Var);
	}
	
	public void setVar(T var) {
		this.var = var;
	}
	
	public T getVar() {
		return this.var;
	}
	
}

在这个类中，我们构造了一个泛型类InfoImpl，然后把泛型变量T传给了Info，这说明接口和泛型类使用的都是同一个泛型变量。
然后在使用时，就是构造一个泛型类的实例的过程，使用过程也不变。

Generic1 generic1 = new Generic1("定义泛型接口的子类");
		System.out.println(generic1.getVar());

使用泛型类来继承泛型接口的作用就是让用户来定义接口所使用的变量类型，而不是像方法一样把它写死。

3.3 构造一个多个泛型变量的类：

interface Info{
	public T getVar();
	public void setVar(T var);
}

class InfoImpl implements Info{
	private T x;
	private K y;
	private U var;
	
	public InfoImpl(U var) {
		this.setVar(var);
	}
	
	public void setVar(U var) {
		this.var = var;
	}
	
	public U getVar() {
		return this.var;
	}
}

public class GenericsDemo1 {

	public static void main(String[] args) {
		InfoImpl i = new InfoImpl("多个泛型变量");
		System.out.println(i.getVar());
	}
}

3.4 泛型函数定义及使用：

单独在一个函数里面使用泛型：

public class StaticFans {

	public static void main(String[] args) {
		StaticFans staticFans = new StaticFans();
		staticFans.StaticMathod("静态方法一：");//使用方法一
		staticFans.StaticMathod("静态方法二： ");//使用方法二
		
		staticFans.OtherMethod(new Integer(100));//使用方法一
		staticFans.OtherMethod(new Integer(100));
	}//使用方法二
	
	public static  void StaticMathod(T a) {
		System.out.println("staticMathod: " + a.toString());
	}
	
	public  void OtherMethod(T a) {
		System.out.println("OtherMethod: " + a.toString());
	}
}

方法一：可以像普通方法一样，直接传值，任何值都可以（但必须是派生自Object类的类型，比如String,Integer等），函数会在内部根据传进去的参数来识别当前T的类别。但尽量不要使用这种隐式的传递方式，代码不利于阅读和维护。因为从外观根本看不出来你调用的是一个泛型函数。
方法二：与方法一不同的地方在于，在调用方法前加了一个来指定传给的值，如果加了这个来指定参数的值的话，那StaticMethod（）函数里所有用到的T类型也就是强制指定了是String类型。这是我们建议使用的方式。

3.5 其他用法：Class类传递及泛型数组：

使用Class传递泛型类对象：

SuccessModel是自定义的解析类

public class SuccessModel {

	private boolean success;
	
	public boolean isSuccess() {
		return success;
	}
	
	public void setSuccess(boolean success) {
		this.success = success;
	}
	public static void main(String[] args) {
		
	}
	
	public static List parseArray(String response){
		List modelList = JSON.parseArray(response,SuccessModel.class);
		return modelList;
  	}
  }

public static  List parseArray(String response,Class object){
		List modeList = JSON.parseArray(response,Object);
		return modeList;
	}

**定义泛型数组：**String[] list = new String[8];

//定义
public static  T[] fun1(T...args){
return arg;
}
//使用
public static void main(String args[]){    
       Integer i[] = fun1(1,2,3,4,5,6) ;  
       Integer[] result = fun1(i) ;  
}

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/zaji/4997165.html

java学习笔记一（2021.11.02）

发表评论

评论列表（0条）