java总结1

2022.3.22

一、

1.类的定义：① class 类名称{ 代码} ②public class 类名称{代码}

①文件名称与类名称不相同生成*.class文件，可以同时有多个class定义，并保存在不同的*.class文件中

②文件名称必须与类名称保持一致*.java且只允许有一个public class定义

2.主方法：主方法main()是一切程序的起点

public static void main（String args[]){

执行的代码；

}

3.系统输出

①Sytem.out.println();输出之后追加一个换行

②Sytem.out.print();输出之后不追加换行

4.classpath属性

可以使用set classpath命令指定Java类的执行路径。

注：PATH：是操作系统的环境属性，指的是可以执行命令的程序路径。

CLASSPATH：是所有的*.class文件的执行路径，Java命令执行时将利用此路径加载所需要的*.class文件。

二、

1.java中的标识符

包、类、方法、参数和变量：任意顺序的大小写字母、数字、下划线、（_)和$,不能以数字开头，也不能时Java关键字

2.关键字

abstract assert boolean break byte case catch char class continue const default do

double else extends enum final finally float for goto if implements import

instanceof int interface long native new package private protected public return short static synchronized super strictfp this throw throws transient try void volatile while

3.基本数据类型

4.转义字符

\f 换页 \b倒退一格 \r归位

5.

在float定义后加上f或F 3.f double定义后加上D或d 3.0d

boolean 的值只能是true或false

6.基本数据类型默认值

byte:0 short :0 int:0 long:0L float:0.0f double：0.0d char :\u000空 boolean:false

7.数据类型的自动转换

①自动（扩大)类型转换

（1）转换前的数据类型与转换后的数据类型兼容。

（2）转换后的数据类型表示范围比转换前的类型大。

（3）boolean不可能做类型的转换。

注：String 转型 +表示字符串连接含义

（1）String可以像普通变量那样直接通过赋值的方式进行声明，字符串使用“”，两个字符串之间可以使用+进行连接。

（2）任何数据类型碰到String的变量或常量都向String转型。

System.out.println("1+2="+1+2) 1+2=12

System.out.println("1+2="+(1+2)) 1+2=3

②强制类型转换

（欲转换的数据类型）变量名称；

8.判断语句、逻辑表达式产生的返回值是布尔值 true false

if(布尔表达式）{语句；}

逻辑运算符

&与：要求所有的条件都判断

&&短路与：如果第一个条件为false,则后面的条件将不在判断

|或：要求所有的条件都判断

||短路或：如果的一个条件为true,则后面的条件将不在判断

9.switch语句中的选择值可以是字符、常量或者String型数据(判断过程之中会区分字符串大小写)

三、

1.数组的定义及使用

①一维数组

（1） 声明： 数据类型 数组名称[]=null ; / 数据类型[] 数组名称=null; (null表示引用数据类型的默认值，暂时还没有任何指向的内存空间）

分配空间：数组名称=new 数据类型[长度]；

初始化：数据类型 数组名[]={初值0，初值1，.....，初值n}

（2）数据类型 数组名[]=new 数据类型[个数]；

数组长度：数组名称.length;

②二维数组

（1）声明：数据类型 数组名[][];

分配空间： 数组名=new 数据类型[行的个数][列的个数]；

（2）数据类型 数组名[][]=new 数据类型[行的个数][列的个数]；

初始化： 数据类型 数组名[][]={{第0行初值}，{第1行初值}，........., {第n行初值}}；

2.方法的声明与使用

方法定义：

public static 返回值类型 方法名称（类型 参数1 ，类型 参数2，....）{

程序语句；

[return 表达式];

}

注：在定义类时，要求全部单词的首字母必须大写，在定义方法时，第一个单词的字母小写，之后的每个单词首字母大写。

3.方法重载：方法名称相同，但参数的类型和参数的个数不同，对于同一方法要统一返回值类型

4.方法返回一个数组 int temp[]=fun()

int ss[]={1,3,4,5}; return ss;

5.排序操作：直接使用java.util.Arrays.sort(数组名称)

复制操作：直接使用Sytem.arraycopy(源数组名称，源数组开始点，目标数组名称，目标数组开始点，赋值长度)

2022.3.23

一、

1.java新特性

①可变参数：方法中接收的参数不再是固定的，随着需要传递

定义格式： 返回值类型 方法名称（类型...参数名称）{}

public static void fun(int...arg){}

②foreach输出

定义格式：for(数据类型 变量名称 ：数组名称）{}

for(int x : arg)

2.面向对象

特性：封装性、继承性、多态性

①封装性：把对象的属性和行为看成一个密不可分的整体，将这两者封装在一个不可分割的独立单位中。为封装在一个整体内的变量及方法规定了不同级别的可见性或访问权限。

②继承性：在Java程序设计中，已有的类可以是Java开发环境所提供的一批最基本的程序--类库，用户开发的程序类是继承这些已有的类。

单继承：一个子类只允许继承一个父类。 多继承：运行继承多个父类。

③多态性：多态是允许程序中出现重命名现象。

注：

方法重载：在一个类中，允许多个方法使用同一个名字，但方法的参数不同，完成的功能也不同。

对象多态：子类对象可以与父类对象进行相互转换，而且根据其使用的子类的不同完成的功能也不同。

3.类与对象的关系

类：定义了一个基本的模板，代表着一个共性。

对象：每个具体的人，根据不同给予不同的姓名，代表一个个性。

①类的定义：类是由属性和方法组成的，属性中定义类需要一个个的具体信息，一个属性就是一个变量，方法是一些操作的行为。

class 类名称{

数据类型 属性：

..................

public 返回值的数据类型 方法名称（参数1，参数2.......){

程序语句；

[return 表达式；]

}

}

例：class Person{

String name;

int age;

public void tell() {

System.out.println("姓名："+name+",年龄："+age);

}

}

②对象的创建及使用：需通过对象使用上面的类

对象的创建 : 类名 对象名称=new 类名（）；

声明对象： 类名 对象名称=null

实例化对象：对象名称=new 类名();

所有的对象名称都在栈内存中保存，而对象的具体内容则保存在对应的堆内存之中，必须使用new关键字才能开辟堆内存空间。

成员变量：堆内 局部变量：栈内 当两者有名称相同时，在方法调用中遵循就近原则。

例：class Person{

String name;

int age;

public void tell() {

System.out.println("姓名："+name+",年龄："+age);

}

}

public class Dem{

public static void main(String args[])

{

Person per=new Person();

}

}

③访问对象中的属性和方法

访问属性：对象名称.属性名

访问方法：对象名称.方法名（）

例：class Person{

String name;

int age;

public void tell() {

System.out.println("姓名："+name+",年龄："+age);

}

}

public class Dem{

public static void main(String args[])

{

Person per=new Person();

per.name="张三";//属性赋值

per.age=15;

per.tell();//调用类中的方法

}

}

4.垃圾空间的释放

java本身提供垃圾收集机制GC，会定期的释放不用的内存空间，只要对象不适用了，就会等待GC释放空间。

一个栈内存空间只能指向一个堆内存空间，如果要想再指向其他的堆内存空间，则必须先断开已有的指向才能分配新的指向。

二、

1.封装性：对外部不可见

为属性封装： private 属性类型 属性名称：

为方法封装 private 方法返回值 方法名称（参数列表）{}

例 class Person{

private String name;

private int age;

public void tell() {

System.out.println("姓名："+name+",年龄："+age);

}

}

只要是封装的属性，必须通过setter和getter方法设置和取得

例 class Person{

private String name;

private int age;

public void tell() {

System.out.println("姓名："+name+",年龄："+age);

}

public String getName(){//取得 返回值类型

return name;

}

public void setName(String n){//设置 void

name=n;

}

}

public class Dem{

public static void main(String args[])

{

Person per=new Person();

per.setName("张三");//调用设置

per.setAge=15;

per.tell();//调用类中的方法

}

}

注意：类中全部属性都必须封装，封装之后的属性必须通过setter和getter进行访问。

private声明的属性或方法只能再其类的内部被调用，而不能再类的外部被调用。

三、

1.构造方法

定义：

class 类名称{

访问权限 类名称 （类型1 参数1，类型2 参数2，.....){

程序语句；

.........//构造方法没有返回值

}

}

注：①构造方法的名称必须与类名称一致。

②构造方法的声明处不能有任何返回值类型的声明。

③不能在构造方法中使用return返回一个值。

④一个类中至少存在有一个构造方法。

⑤构造重载：只要每个构造方法的参数类型或参数个数不同，所有的重载的方法按照参数的个数由多到少，或者由少到多。

例：class Person{

private String name;

private int age;

public Person(String name,int age){//定义构造方法为属性初始化

this.setName(name);

this.setAge(age);

}

public class Dem{

public static void main(String args[])

{

Person per=new Person("张三","30");//调用构造方法，传递两个参数

per.tell();

}

}

2.匿名对象

匿名对象没有明确的给出名字的对象，匿名对象只使用一次，而且匿名对象只在堆内存中开辟空间，而不存在栈内存的引用。

public class Dem{

public static void main(String args[])

{

new Person("张三","30").tell();//匿名对象

}

}

2022.3.25

一、

1.String类

①实例化String类对象

（1)直接赋值 String name ="";

(2)直接调用String类中的构造方法 public String(String original)

②String对象的内容比较

（1）使用“==”（地址比较）进行内容比较

（2）String提供的方法 public boolean equals(String str);//会区分大小写 str.equals(str2)

区别："=="是java提供的关系运算符，主要的功能是进行数值相等的判断，如果用在了String中表示的是内存地址数值的比较。

equals（）方法是由String提供的一个方法，负责进行字符串内容的比较。

③String 类两种对象实例化方式的区别

一个字符串就是一个String类的匿名对象，匿名对象就是已经开辟了堆内存空间的并可以直接使用的对象。

（1）直接赋值的方式

String str1="hello";

String 使用直接赋值的方式之后，只要是以后声明的字符串内容相同，则不会再开辟新的内存空间。

（2）使用new String()方式

String str=new String("hello");//两个空间

一个字符串就是一个String类的匿名对象，如果使用new 关键字的话，不管如何都会再开辟一个新的空间 。一个是使用关键字new开辟的空间，一个是垃圾空间。

区别：直接赋值：只会开辟一块堆内存空间，并且会自动保存在对象池之中以供下次重复使用。

构造方法：会开辟两块堆内存空间，其中一块空间将成为垃圾，并且不会自动入池，但是用户可以使用intern()方法手工入池。

④字符串的内容：字符串的内容一旦声明则不可改变

一个String对象内容的改变实际上是通过内存地址的"断开--连接"变化完成的，而本身字符串中的内容并没有任何的变化。

⑤String类中常用的方法。