JAVA

最新推荐文章于 2023-09-08 22:30:00 发布

爱喝可乐的67

最新推荐文章于 2023-09-08 22:30:00 发布

阅读量291

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_41053152/article/details/115355986

版权

1 JAVA 的数据类型

在这里插入图片描述
分为两大类:
基本数据类型:类似普通的值（8）
引用数据类型:传递内存地址

数据类型有自己的取值范围,当超出范围时编译会报错:
在这里插入图片描述

整数类型

最大值+1会发生数据溢出,变成最小值:
在这里插入图片描述
为了避免数据溢出,可以扩大数据类型.int---->long

字符型

字符型在内存中占2个字节,用来保存英文字母等字符。计算机处理字符型数据时当成不同的整数对待。
在这里插入图片描述

char类型定义时，必须用单引号括起来。

不太理解为什么取值范围0~255

浮点数

java中的整数/小数的默认类型为int / double
因此定义一个float类型的变量：
float num = 31.2f;

布尔类型

true /false

数据类型的转换

（1）自动类型转换
转换后的数据类型的表示范围比转换前的类型大
在这里插入图片描述 int+ float---->float
int +double---->double
int+int---->int，默认忽略小数

提示：所有的数据类型都会向String转型。
在这里插入图片描述 a+b时如果有“a+b”则String+int------->String

（2）强制类型转换
(欲转换数据类型)变量名称
在这里插入图片描述

2. 运算符、表达式与语句

赋值运算符

算术运算符

，+ ， -， *， /， %

关系运算符

， < ， >= ，<= ， == ， !=，>
返回布尔值true/false ,一般与if语句一起使用

递增与递减运算符

++a:先自增再计算
a++:先计算再自增
a- -，- -a同理

逻辑运算符

& ======与
&& =====短路与
|=======或
||======短路或

不管是否短路，其基本的操作结果是一样的，使用与，true+true=true，否则就是false，
使用或，false+false=false，否则是ture。

对于‘与‘和’或‘来说，要求所有条件都判断，而如果使用’短路与‘和’短路或‘，当判断第一个条件为false/true，则后面条件不再判断。

短路与和短路或常被使用

括号运算符

（）

位运算符

&==============按位与
|=============按位或
^============异或（相同为0，不同为1）
~======================取反
<</>>/>>>================左/右位移/无符号右移位

要想进行位操作，则需要先将十进制的数据变为二进制数据，除2的形式，求余数。
在这里插入图片描述

左移操作是将位运算数的二进制码整体左移指定位数，左移之后的空位用0填充。

各个运算符的优先级

在这里插入图片描述

程序结构：

1。顺序结构：程序从上到下逐条执行。
2。选择结构：根据条件的成立与否，再决定要执行哪些语句的一种结构。

if (判断条件){
语句1；
}

if（判断条件）{
语句1；
}else{
语句2；
}

变量=条件判断?表达式1：表达式2
max=x>y?x:y

if–else本身是两种结果，如果现在有多种结果需要判断，则用多条件判断。
if (条件判断1){
语句1；
}else if（条件判断2）{
语句2；
}
…//多个else if
else{
语句3；
}

对于多条件判断，可以用switch语句。
switch (表达式){
case 值1：语句1；break;
case 值2：语句2；break；
…
default：语句n;break;
}
表达式只能使用数字或者字符。每个语句之后都有一个break，此语句表示退出整个switch语句，如果不写上此语句，则在第一个满足条件之后的语句之后所有语句全部输出，直到遇到break。所以使用时必须加上break
在这里插入图片描述

3。循环结构：根据判断条件的成立与否，决定程序段落的执行次数。
（1）while
while（循环条件判断）{
语句1；
语句2 ；
…
语句n;
循环条件更改；
//否则有可能死循环
}
（2）do – while
do{
语句1；
语句2；
…
语句n；
循环条件改变；
}while(循环条件判断)
(3)for----已经知道执行次数
for(赋值初值；判断条件；条件改变){
语句1；
…
语句n；
}
在这里插入图片描述

中断语句

1 break：强迫中断循环，跳出循环结构
2 continue: 强迫程序中断一次，并跳到循环的起始处

3. 数组与方法

数组：一组相关数据的集合。一维数组、二维、多维。int i[100]，引用类型。引用传递的是内存的使用权，一个内存空间，可能有多个人同时使用。

一维数组可以存放上千万个数据，并且这些数据的类型都是完全相同的。要使用数组：
（1）声明数组：数据类型数组名[]=null;
（2）分配内存给该数组（堆内存开辟空间，默认值0）: 数组名=new 数据类型[长度]

堆栈内存的解释：
数组操作中，在栈内存中保存的永远是数组的名称，只开辟了栈内存空间的数组是永远无法使用的，必须有指向的堆内存才可以使用，要想开辟新的堆内存则必须使用new关键字，之后只是将此堆内存的使用权交给了对应的栈内存空间，而且一个堆内存空间可以同时被多个栈内存空间指向，即一个人可以有多个名字，人就相当于堆内存，名字就相当于栈内存。
在这里插入图片描述
取得数组长度：
数组名称.length

数组的初始化

数组的内容分为动态初始化和静态初始化两种。
动态初始化：先声明数组之后为数组中的每个内容赋值。
在这里插入图片描述

静态初始化：在声明时就指定具体内容。
数据类型数组名[]={初值1，初值2…初值n}
在这里插入图片描述

二维数组

动态初始化：
在这里插入图片描述
静态初始化
int score[][]={{1,2,3,4},{3,5,3,1},{4,6,8}}

方法

定义：一段可以重复调用的代码段。
格式：
public static 返回值类型方法名称(类型参数1，类型参数2，…){
return xxx；
}

方法重载

定义：方法名称相同，但参数的类型和参数个数不同，通过传递参数的个数及类型不同以完成不同功能的方法调用。

如：System.out.print()方法也可以打印任何数据。因此也属于重载方法。

return

return可以返回方法的结果，也可以用来结束一个方法。 return
在这里插入图片描述
输出结果：
1
3
2

方法的递归调用

定义：特殊的调用，方法自己调用自己

数组的引用传递

接受和返回数组：
一个方法可以接受一个数组，也可以返回一个数组，如果方法接受一个数组的话，则此方法对数组所作的修改将全部被保存下来。
在这里插入图片描述

方法也可以返回数组，只需明确定义类型。
public static int[] arg()

java中提供数组的排序支持：
java.util.Arrays.sort（a）；

数组拷贝

将一个数组中指定位置的内容拷贝给另一个数组。需要知道：

原数组
原数组起始点
目标数组
目标数组的起始点
拷贝长度

在这里插入图片描述
java支持：System.arraycopy(i1,2,i2,3,2)

可变参数

定义：一个方法在调用的时候必须根据其规定的参数传递，规定5个参数，必须传入5个，在JDK1.5之后，为了让方法更加据有灵活性，使用可变参数的概念，在调用方法的时候可以传递任意多个参数。

格式：返回值类型方法名称(类型…参数名称){ }
在这里插入图片描述

foreach输出

数组的输出，一般都会使用for循环输出，JDK1.5后可以使用foreach输出：
格式：
for(数据类型变量名称:数组名称){
…
}
在这里插入图片描述

4. 面向对象

三个主要特征：

封装：对外部不可见，可以保护程序中的某些内容。
继承：扩展类的功能。
多态：方法的重载、对象的多态。

类与对象的关系

类：某一类事物的描述，抽象、概念上的定义。相当于一个模板。Person
对象：实际存在的该类事物的每个个体，也称为实例。
对象保存在栈内存，具体内容保存在堆内存。
对象间的引用传递，实际上传递的就是堆内存空间的使用权。
类的格式：
class 类名称{
//声明成员变量
数据类型属性1；
数据类型属性2；
。。。

//定义方法
}
对象创建与使用
类名对象名称=null;
对象名称=new 类名();

类图表示：
第一层：类名称
第二层：属性定义 ”访问权限属性名称：属性类型“
第三层：方法定义 ”访问权限方法名称（）：方法返回值“
在这里插入图片描述

JAVA中的内存划分

类属于引用传递类型，从数组中可以知道，引用数据类型必然存在栈内存-堆内存的引用关系。实际上类与对象的使用上仍存在这样的关系。
声明对象

声明对象：Person per ，栈内存中声明的，与数组一样，数组名称就保存在栈内存中，只开辟了栈内存的对象是无法使用的，必须有其堆内存的引用才可以使用。
实例化对象：new Person（），堆中开辟空间，所有的内容都是默认值。
—String：null
—int: 0
开发中，最好给一个初值，这样操作比较方便。
为对象赋值：
调用属性：per.name=“张三”；
调用方法： per.tell()

对象是保存在栈内存中，属性是保存在堆内存之中。而方法保存在全局代码区之中的。此区中的内容是所有对象共享的。
两个对象的示例：（方法共享）

类是引用数据类型，实际上传递的是堆内存的使用权，可以同时为一个堆内存空间定义多个栈内存的引用操作。

p1,p2均有自己对应的堆内存：

这样p2之前指向的堆内存空间没有栈内存指向，变成了垃圾，等待垃圾收集机制（GC）进行回收。

垃圾的产生分析

在这里插入图片描述

第一个特性：封装性

封装的产生目的：

保护内容。
保证某些属性或方法可以不被外部看见。

封装的实现

private 为属性和方法进行封装，则外部无法调用。
因为这些属性肯定是要表示出一些实际的意义，那么这些意义的内容肯定应该由外部设定，所以在整个JAVA中对于封装性的访问给出了一个明确的原则，此原则必须遵守。
被封装的属性如果需要被访问，则需要编写setter和getter方法完成。

例如：private String name;
Setter（设置）：public void setName(String n){}
Getter(取得)：public String getName(){return name;}

setter和getter

在这里插入图片描述

构造方法

定义：
class 类名称{
访问权限类名称（类型1 参数1 ，类型2 参数2，…）{
程序语句；
}
}
注意：

构造方法的名称必须与类名称一致
构造方法的声明处不能有任何返回值类型的声明
不能在构造方法中使用return返回一个值
只有在实例化对象时才会调用方法，声明对象不会调用
如果一个类中没有明确的声明一个构造方法，则会自动生成一个无参的什么都不做的构造方法。

有参构造函数

当声明了有参构造函数则不能自动调用无参构造函数。
在这里插入图片描述

构造方法重载

同普通方法一样，参数个数和类型不同就可以实现构造方法的重载。
在这里插入图片描述

匿名对象

匿名:

没有名字，在java中如果一个对象只使用一次，则就可以将其定义成匿名对象。
匿名对象只在堆内存中开辟空间而不存在栈内存的引用。只开辟堆内存的对象实例。

eg. new Person(“张三”，30).tell（）；

实例讲解–Student类：

package test1;

public class test1 {
	public static void main(String args[]) {
		Student s1=new Student(2018,"张三",76,89,67);
		s1.info();
	}
}

class Student{
	private int snum;
	private String sname;
	private float math;
	private float english;
	private float computer;
	public Student() {
		
	}
	public Student(int snum,String sname,float math,float english,float computer) {
		this.setComputer(computer);
		this.setEnglish(english);
		this.setMath(math);
		this.setSname(sname);
		this.setSnum(snum);
	}
	public int getSnum() {
		return snum;
	}
	public void setSnum(int snum) {
		this.snum = snum;
	}
	public String getSname() {
		return sname;
	}
	public void setSname(String sname) {
		this.sname = sname;
	}
	public float getMath() {
		return math;
	}
	public void setMath(float math) {
		this.math = math;
	}
	public float getEnglish() {
		return english;
	}
	public void setEnglish(float english) {
		this.english = english;
	}
	public float getComputer() {
		return computer;
	}
	public void setComputer(float computer) {
		this.computer = computer;
	}
	
	public float sum() {
		return this.getMath()+this.getComputer()+this.getEnglish();
	}
	public float avg() {
		return this.sum()/3;
	}
	public float max() {
		float max = this.getMath();
		if(this.getComputer()>max){
			max = this.getComputer();
		}
		if(this.getEnglish()>max){
			max = this.getEnglish();
		}
		return max;
	}
	public float min() {
		float min = this.getMath();
		if(this.getComputer()<min){
			min = this.getComputer();
		}
		if(this.getEnglish()<min){
			min = this.getEnglish();
		}
		return min;
	}
	public void info() {
		System.out.println("姓名："+this.sname+",学号："+this.snum+",数、英、计算机成绩为："+this.math+","+this.english+","+this.computer);
		System.out.print("最高分："+this.max()+", 最低分："+this.min());
	}
}

String类

String类的两种实例化方式

（1）直接赋值
String name = “liuqiqi”;

（2）通过new关键字
String name = new String(“liuqiqi”);

String类的两种比较操作

==：基本类型中以此进行数据的比较。
在String类中，判断的地址空间是否相等。
如果想判断内容是否相等，则需要使用equals。
在这里插入图片描述

在这里插入图片描述
equals()进行比较：

分析String类两种实例化方式的区别

（1）直接赋值
首先，
一个字符串是一个String类的匿名对象。
如下：可以调用equals方法。所以对于直接赋值的
String name = “liuqiqi”;
可以知道“liuqiqi”在堆内存中，并将该堆内存空间的指向给了栈内存空间name。

在这里插入图片描述
直接赋值2个字符串变量，并用==比较内存空间。发现是一样的。

当直接赋值时，开辟一个堆内存空间，如果现在有别的直接赋值的内容一样，那么不会开辟新的堆内存空间。因此使用直接赋值的方式可以节省内存空间。
在这里插入图片描述
（2）new新建
hello 是匿名对象，开辟堆内存空间。然后New后，会再开辟一个空间。也就是开辟了2个空间。

使用直接赋值的方法只需要一个实例化对象即可，而使用new String（）的方法则意味着要开辟两个内存对象，开发中最好使用直接赋值的方式完成。

String类的使用特点

String字符串内容不可改变。
在这里插入图片描述
改变的是堆内存地址的指向。

String类常用方法

（1）字符串<----->字符数组：

字符串------>字符数组：
public char[] toCharArray()
字符数组------>字符串(构造函数)：
public String(char[] value)
public String(char[] value,int offset,int count)
在这里插入图片描述

(2)从字符串取出指定位置的字符

public char charAt（int index）
在这里插入图片描述

(3)字符串与byte数组的转换

字符串------->字节数组：
public byte[] getBytes()
字符数组------>字符串（构造函数）：
public String(byte[] bytes)

public String(byte[] bytes,int offset,int length)

(4)取得字符串长度

pulic int length()

    	  String str1 = "hello";
    	  System.out.println(str1.length());

(5) 查找指定的字符串是否存在

从头开始查找：
public int indexOf(String str)
从指定位置开始查找：
public int indexOf(String str,int fromIndex)

查找的时候方法返回int类型数据，数据表示一个字符串的具体位置，如果没有查找到此字符串，则返回“-1”.

在这里插入图片描述

(6)去掉字符串前后的空格

str1.trim()

(7)字符截取

从指定位置开始一直截取到结束位置：
public String substring(int beginIndex)

截取指定范围的字符串：
public String substring(int beginIndex,int endIndex)
在这里插入图片描述

(8)拆分字符串

public String[] split(String regex)

    	  String str1 = "hello world";
    	  String str2[] = str1.split(" ");
    	  for(int i=0;i<str2.length;i++) {
    		  System.out.println(str2[i]);
    		  }

(9)大小写转换

大写----->小写：
public String toLowerCase()
小写----->大写：
public String toUpperCase()

    	  String str1 = "hello world";
    	  String str2 = "HELLO WORLD";
    	  System.out.println(str1.toUpperCase());
    	  System.out.println(str2.toLowerCase());

(10)判断是否以指定的字符串开头或结尾

public boolean startsWith(String prefix)
public boolean endsWith(String suffix)

(11)不区分大小写的比较

equals()方法用来进行字符串比较的，但此种比较方法只能针对大小写完全一样的字符串进行比较，如果现在想不区分大小写，则：
public boolean equalsIgnoreCase(String anotherString)

(12) 字符串替换功能

public String replaceAll(String regex,String replacement)

引用传递

（1）在这里插入图片描述
内存分析：

（2）String内容不可变在这里插入图片描述
内存分析：

（3）在这里插入图片描述
内存分析：

关于java内存的分析详见：
https://blog.csdn.net/qq_36743482/article/details/78527312

this

this关键字的作用：

表示类中属性
属性用this.属性表示this.age=age；

package test1;
public class ClassDemo{
 public static void main(String args[]) {
  Person p1=new Person("张三",16);
  System.out.print(p1.tell());
 }
}
class Person {
 //姓名、年龄
 private String name;
 private int age;

 public String tell() {
  return "姓名"+name+age;
 }
 public Person(String name,int age) {
  name=name;
  age=age;
 }

}

输出：姓名null0 //此时操作的name和age实际上都是构造方法中的，和类的属性完全不沾边。如果1.传参是(n,a)可以赋值。2. 加this表示类的属性。

package test1;
public class ClassDemo{
 public static void main(String args[]) {
  Person p1=new Person("张三",16);
  System.out.print(p1.tell());
 }
}
class Person {
 //姓名、年龄
 private String name;
 private int age;

 public String tell() {
  return "姓名"+name+age;
 }
 public Person(String name,int age) {
  this.name=name;
  this.age=age;
 }

}

输出：姓名张三16

调用本类的构造方法
为每个构造函数加一个输出"对象实例化"。

package test1;
public class ClassDemo{
 public static void main(String args[]) {
  Person p1=new Person("张三",16);
  System.out.print(p1.tell());
 }
}
class Person {
 //姓名、年龄
 private String name;
 private int age;

 public String tell() {
  return "姓名"+name+age;
 }
 public Person() {//无参构造
	 System.out.println("新对象实例化");
 }
 public Person(String name) {//一个参数
	 System.out.println("新对象实例化");
	 this.name=name;
 }
 public Person(String name,int age) {
	 System.out.println("新对象实例化");
     this.name=name;
     this.age=age;
 }

}

this调用构造方法后：

package test1;
public class ClassDemo{
 public static void main(String args[]) {
  Person p1=new Person("张三",16);
  System.out.print(p1.tell());
 }
}
class Person {
 //姓名、年龄
 private String name;
 private int age;

 public String tell() {
  return "姓名"+name+age;
 }
 public Person() {//无参构造
	 System.out.println("新对象实例化");
 }
 public Person(String name) {//一个参数
	 this();
	 this.name=name;
 }
 public Person(String name,int age) {
	 this(name);
     this.age=age;
 }

}

使用this调用其他构造方法的时候，限制：
（1）this()调用构造方法的语句只能放在构造方法的首行。
（2）在使用this调用本类中其他构造的时候，至少有一个构造方法是不用this调用的。-------构造方法出现递归调用。

表示当前对象
当前对象：当前正在调用方法的对象。

package test1;
public class ClassDemo{
 public static void main(String args[]) {
  Person p1=new Person();
  Person p2=new Person();
  System.out.println("main方法中："+p1);
  p1.getInfo();
  System.out.println("main方法中："+p2);
  p2.getInfo();
 }
}
class Person {
	public String getInfo() {
		System.out.println("Person类："+this);
		return null;
	}
}

输出：
main方法中：test1.Person@15db9742
Person类：test1.Person@15db9742
main方法中：test1.Person@6d06d69c
Person类：test1.Person@6d06d69c

this应用-----对象的比较

1.在主方法中依次取得各个属性进行比较

 if(p1.getName().equals(p2.getName())&&p1.getAge()==p2.getAge()) {
	    	System.out.print("两个对象相等");
	    }

2 比较的时候由自己进行比较，即在Person类中增加一个比较的方法。

package test1;
public class ClassDemo{
	public static void main(String args[]) {
		Person p1=new Person("张三",16);
		Person p2=new Person("张三",16);
	    if(p1.compare(p2)) {
	    	System.out.println("两个对象相等");
	    }else {
	    	System.out.println("两个对象不相等");
	    }
	}
}
class Person {
	//姓名、年龄
	private String name;
	private int age;
	public void setName(String n) {
		name=n;
	}
	public String getName() {
		return name;
	}
	public void setAge(int a) {
		age=a;
	}
	public int getAge() {
		return age;
	}
	public void tell() {
		System.out.println("姓名："+name+"，年龄："+age);
	}
	public Person(String n,int a) {
		this.setName(n);
		this.setAge(a);
	}
	public boolean compare(Person p) {//接收本类的引用
		if(this==p) {//地址相等，属性一定相等
			return true;
		}
		if(this.getName().equals(p.getName())&&this.getAge()==p.getAge()) {
			return true;
		}else {
		return false;
		}
		
	}

}

static关键字

在Java中可以使用static声明属性或方法，因为在之前所讲解的属性和方法都属于非static的，这样一来，每个对象都占有各自的内容，如果希望一个属性被所有对象所共同拥有，则可以将其声明为static类型，声明static类型的属性或方法之后此属性或方法也称为类方法，可以由类名称直接调用。

package test1;

public class staticMethod {
	public static void main(String args[]) {
		People p1=new People("张三",12);
		People p2=new People("李四",13);
		People p3=new People("王五",14);
		p1.info();
		p2.info();
		p3.info();
}
}

class People{
	String name;
	int age;
	String country="上海";
	public People(String name,int age) {
		this.name=name;
		this.age=age;
	}
	public void info() {
		System.out.println("name:"+this.name+",age:"+this.age+",country:"+country);
	}
}

以上代码确实实现了一些基本的功能，但是如果此时城市的名字从上海改为北京，如果限制已经产生了5000个对象，那么意味着要修改5000个对象的城市属性，所以此时最好使用关键字声明属性。

使用static修改城市属性。

package test1;

public class staticMethod {
	public static void main(String args[]) {
		People p1=new People("张三",12);
		People p2=new People("李四",13);
		People p3=new People("王五",14);
		System.out.println("----------------修改前----------------------");
		p1.info();
		p2.info();
		p3.info();
		p1.country="北京";
		System.out.println("----------------修改后----------------------");
		p1.info();
		p2.info();
		p3.info();
}
}

class People{
	String name;
	int age;
	static String country="上海";//static
	public People(String name,int age) {
		this.name=name;
		this.age=age;
	}
	public void info() {
		System.out.println("name:"+this.name+",age:"+this.age+",country:"+country);
	}
}

----------------修改前----------------------
name:张三,age:12,country:上海
name:李四,age:13,country:上海
name:王五,age:14,country:上海
----------------修改后----------------------
name:张三,age:12,country:北京
name:李四,age:13,country:北京
name:王五,age:14,country:北京

修改一个对象的城市属性，则其他对象的城市属性内容全部改变，证明此属性是所有对象共享的。
在这里插入图片描述
每一个对象都拥有各自的堆栈空间，堆内存空间中保存每个对象各自的属性，但是所有的static属性是保存在了全局数据区中，所有对象指向全局数据区中的一个内容，所以当一个对象修改之后，所有对象的内容将全部变化。

Java 中到底有多少个内存区域呢？

栈内存：保存对象的名称（保存访问的堆内存的地址）
堆内存：保存每个对象的具体属性
全局数据区：保存static类型的属性
全局代码区：保存所有方法的定义

但是，如果现在观察之前编写的代码也会发现一些问题，用对象调用静态变量不是很合理，因此一般在调用static属性的时候最好是使用类名称直接调用，采用“类名称.属性”的形式调用。
People.country=“北京”;

static声明属性，也可以声明方法。
如果一个方法使用了static关键字声明，则此方法可以直接使用类名称进行调用。

package test1;

public class staticMethod {
	public static void main(String args[]) {
		People p1=new People("张三",12);
		People p2=new People("李四",13);
		People p3=new People("王五",14);
		System.out.println("----------------修改前----------------------");
		p1.info();
		p2.info();
		p3.info();
		People.setCountry("北京");
		System.out.println("----------------修改后----------------------");
		p1.info();
		p2.info();
		p3.info();
}
}

class People{
	private String name;
	private int age;
	private static String country="上海";//static
	
	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;
	}
	
	public static String getCountry() {
		return country;
	}
	public static void setCountry(String country) {
		People.country = country;
	}
	public People(String name,int age) {
		this.name=name;
		this.age=age;
	}
	public void info() {
		System.out.println("name:"+this.name+",age:"+this.age+",country:"+country);//static 方法中不能使用this
	}
}

结果是一样的。
注意：
使用static方法，不能调用非static的属性或方法，因为在对象实例化前，static方法、属性就能使用了。

应用：

因为static属性是所有对象共享的，那么就可以使用static属性统计一个类2到底产生了多少个实例化对象。
可以使用static为对象进行自动的编名操作，此操作与上面代码类似。

因为每一个实例化对象在操作的时候必须调用构造方法完成，如果现在要进行统计的话，则直接在构造方法中增加一个static的属性即可。

package test1;

public class staticDemo1 {
	public static void main(String args[]) {
		Demo d1=new Demo();
		Demo d2=new Demo();
		Demo d3=new Demo();
	}
}
class Demo{
	private static int count = 0;
	public Demo() {
		count++;
		System.out.println(count);
	}
}

1
2
3

为对象编名与上面类似。

package test1;

public class staticDemo1 {
	public static void main(String args[]) {
		System.out.println(new Demo().getName());
		System.out.println(new Demo().getName());
		System.out.println(new Demo("lq").getName());
		System.out.println(new Demo().getName());
		System.out.println(new Demo("gyh").getName());
	}
}
class Demo{
	private String name;
	private static int count = 0;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public Demo() {
		count++;
		this.name="Demo-"+count;
	}
	public Demo(String name) {
		count++;
		this.name=name;
	}
}

Demo-1
Demo-2
lq
Demo-4
gyh

main方法

public static void main(String args[])

public: 表示此方法可以被外部所调用
static: 表示此方法可以直接由类名称调用（执行java程序的时候，使用的是java 类名称，找到的肯定是main方法）
void: 主方法是程序的起点，所以不需要任何的返回值
main: 系统规定好默认调用的方法名称，执行的时候，默认找到main方法名称
String args[]: 表示输入的参数

public class staticDemo1 {
	public static void main(String args[]) {
		for(String x:args) {
			System.out.print(x);
		}
	}
}

参数的设置形式，是在类执行的时候加入的：
java 类名称参数1 参数2 …

java staticDemo1 21 32

每个参数用“ ”分割。
如果此时，一个程序运行时必须要求输入的参数是3个，否则无法运行，那么就可以在操作之前进行一个判断判断参数的个数。

public class staticDemo1 {
	public static void main(String args[]) {
		if(args.length!=3) {
			System.out.print("输入参数不是3个，推出");
			System.exit(1);//非0的数字则表示程序退出
		}
		for(String x:args) {
			System.out.print(x);
		}
	}
}

代码块

构造方法私有化

对象数组

内部类

1、定义：在一个类的内部还存在一个类。如Outer类的内部再定义一个类Inner，此时Inner类为内部类，Outer则称为外部类。
2、内部类可以声明为public和private
在外部类的方法中直接实例化内部类的对象并调用内部类的方法。

class OuterClass {
	private String info = "hello";//定义外部类的私有属性
	//定义内部类
	class InnerClass{
		public void print() {
			System.out.println(info);//内部类方法直接调用外部类的私有属性
		}
	};
	
	public void fun() {
		new InnerClass().print();    //内部类实例化对象调用方法
	}

};

public class OuterClassDemo{
	public static void main(String args[]) {
		new OuterClass().fun();
	}
}

3、特点
1）缺点：正常一个类的操作中，在类中最好只定义属性或方法。如果定义一个类的话，则肯定破坏了程序的一个结构
2）优点：拆分代码看效果（内部类和外部类拆成2个类）

单向链表

简单的定义和输出：

package test1;

public class staticDemo1 {
	public static void main(String args[]) {
		Node root=new Node("root");
		Node n1=new Node("n1");
		Node n2=new Node("n2");
		Node n3=new Node("n3");
		root.setNext(n1);
		n1.setNext(n2);
		n2.setNext(n3);
		printNode(root);
	}
	public static void printNode(Node root) {
		System.out.println("第1个节点内容为："+root.getData());
		int count=2;
		while(root.getNext()!=null) {
			root=root.getNext();
			System.out.println("第"+count+"个节点内容为："+root.getData());
			count++;
		}
	}
}

class Node{
	private String data;//保存节点内容
	private Node next;//表示下一个节点
	public Node(String data) {//构造方法设置节点内容
		this.data=data;//设置内容
	}
	public String getData() {
		return data;
	}
	public void setData(String data) {
		this.data = data;
	}
	public Node getNext() {//取得下一个节点
		return next;
	}
	public void setNext(Node next) {//设置下一个节点
		this.next = next;
	}
}

第1个节点内容为：root
第2个节点内容为：n1
第3个节点内容为：n2

递归实现：

public static void printNode(Node root) {
			System.out.println(root.getData());
			if(root.getNext()!=null) {
				printNode(root.getNext());
			}

		}

异常

异常定义

导致程序中断运行的一种指令流。一旦产生异常之后，异常之后的语句并不会执行，而是直接结束程序，并将错误报告给用户。

	public static void main(String args[]) {
	    System.out.println("计算开始");
		int i = 10;
		int j = 0;
		int temp = i/j;
		System.out.println("两个数相除为"+temp);
		System.out.println("计算结束");
	}

异常处理格式

try{
//有可能出现异常的语句
}catch(异常类异常对象){
//编写异常的处理语句
}【catch(异常类异常对象){
//编写异常的处理语句
}catch(异常类异常对象){
//编写异常的处理语句
}。。。。】
【finally{
一定会执行的代码；
}】
在这里插入图片描述

	public static void main(String args[]) {
		System.out.println("计算开始");
		int i = 10;
		int j = 0;
		try {
			int temp = i/j;
			System.out.println("两个数相除为"+temp);
		}catch(ArithmeticException e) {
			System.out.println("算术异常"+e);
		}
		System.out.println("计算结束");
	}

运行结果：

计算开始
算术异常java.lang.ArithmeticException: / by zero
计算结束

以上操作代码中只使用了基本的异常处理格式，try…catch，try中捕获异常，出现异常后的代码将不再被执行，而是跳转到相应的catch语句，用于处理异常。对于异常也可以设置其统一的出口，使用finally完成。不管是否异常都会执行finally。

爱喝可乐的67

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
JAVA

JAVA基础知识1 java运行机制源文件xxx.java------->编译------>xxx.class(字节码文件)------>解释------>计算机执行编译命令: javac.exe 解释命令:java.exe
复制链接

扫一扫