标签：java 复习 int void 笔记 对象 static public String

面向对象

值交换

**值传递：**调用一个方法的时候，传递给方法的参数，实际上传递变量所存储的地址。

交换ab值：

class Demo1 
{
    public static void main(String[]args)
    {
        int a= 5;
        int b= 3;
        changValue(a,b);
        System.out.println("a:"+a+"b"+b);
    }
    public static void changValue(int a,int b)
    {
        int temp;
        temp = a;
        a  = b;
        b = temp;
         System.out.println("方法内部交换的值"+"a:"+a+"b"+b);
    }
}

结果为：a=5,b=3，值未发生交换。

为什么没有交换成功？

1. 形式参数是数据所属函数的局部变量。

2. 不同函数的局部变量与局部变量是相互独立，没有任何的关系。

交换数组值：

import java.util.*;
class Demo1
{
    public static void main(String[]args)
    {
       int []arr = {20,10,9};
		changArr(arr,1,2);
        System.out.println("数组的值"+Arrays.toString(arr));
    }
    public static void  changArr(int [] arr,int index1,int index2)
    {
       int temp;
	   temp = arr[index1];
	   arr[index1] = arr[index2];
	   arr[index2]= temp;
    }
}

为什么会成功？

1. 两个函数的arr还是不同的。
2. arr这两个不同的局部变量只不过是操作了相同的对象，才导致修改成功的。

对象交换：

class Person
{
	int x = 10;
}
class Demo1
{
    public static void main(String[]args)
    {
		Person p = new Person();
		changObj(p,20);
        System.out.println(p.x);
    }
    public static void  changObj(Person p,int x)
    { 
		p.x = x;
    }
}

局部变量

局部变量：

1. 局部变量没有默认初始值 必须初始化
2. 局部变量只能存在自己的作用域中,for循环中

public void may(){
	for(int i =1;i<10;i++){
	
	}
	System.out.print(i); //此时i不存在
}

匿名对象

匿名对象：没有引用类型变量指向的对象称作为匿名对象。

匿名对象要注意的事项:

1. 一般不会给匿名对象赋予属性值，因为永远无法获取到。
2. 两个匿名对象永远都不可能是同一个对象。

面向对象的特性

一:封装

**实体类:**描述一类事物

**工具类:**Arrays

实际开发中,实体类都要封装

二:继承

注意:

• 创建子类对象,默认会调用父类的构造方法

三:多态

**前提:**必须存在继承或者实现关系

动物 a = new 狗

实现关系下的多态：

接口 变量 = new 接口实现类的对象

注意:

• 多态情况下,子父类存在同名成员时,都访问父类成员,除存在同名非静态函数访问子类.
• 多态情况下,不能访问子类特有成员
• 编译看左边,运行不一定看右边
• 左边:查看引用类型变量,是否有指定的成员.
• 右边:除了存在同名非静态函数访问子类.,其余都是父类.

作用:

• 多态用于形参类型的时候,可以接受更多类型的数据
• 多态用于返回值类型的时候,可以返回更多类型的数据

构造函数

**作用:**给对应的对象初始化

细节:

• 一个类没有显式的写构造方法时候,java编译器会在编译的时候,自动调用无参的构造方法

• 一个类显式的写构造方法的情况下,java编译器则不再回为该类添加构造方法

• java编译器添加的无参构造方法的权限修饰符与类的权限修饰符一致

代码块

构造代码块

**作用:**给对象统一初始化

位置: {}必须要位于成员位置上

细节:

• 创建对象时,被调用
• java编译器编译之后,会把构造代码块的代码放入构造器中,先执行

静态代码块

**生命周期:**创建对象之前就已经生成

局部代码块

作用: 缩短局部变量的生命周期节省一点点内存.

位置:{}位于方法之内

关键字

this关键字

**定义:**代表当前所属函数的调用者对象

即 this == new 对象

作用:

• this可以在构造器中,调用成员变量 this.id = id;
• this可以调用本类的其他构造器中的构造方法 this(id);(调用一个参数的构造方法)

注意:

• 调用其他的构造函数时必须位于第一个语句

经典用法:

class Student{
    int id;
    String name;
    public Student(int id,String name){
        this(name);//调用了本类的一个参数的构造方法。
        this.id = id;
    }
    public Student(String name){
        this.name = name;
    }
}

static关键字

使用类名访问成员可以不用创建对象,从而节省内存

静态成员生命周期

静态成员的数据是优于对象存在的

示例:

class Emp{
   static int index;
    public static void may(){
       System.out.println("1213432");
    }
}
class Test{
    public static void main(String[] args) {
        int a = Emp.index;
        Emp.may();
    }
}

static修饰成员变量

**作用:**把数据共享给所有的对象使用

注意:

• 成员变量可以使用类名.变量进行访问,但非静态成员变量不可以

• 静态发成员变量只会在数据共享区中维护一份，而非静态成员变量的数据会在每个对象中都能维护一份。

(修改任意对象的country属性,都会影响到每个对象country)

class Student{
	String name;
    static String country = "中国";//使用了static修饰了country，那么这时候country就是一个共享数据。
    //构造函数
    public Student(String name){
        this.name = name;
    }
class Demo1{
    public static void main(String[]args){
   	 	Student s1 = new Student("李华");
    	Student s2 = new Student("王华");
       // s1.country ="小日本";
       // 输出结果s1,s2国籍都是小日本。
        System.out.println("姓名"+s1.name+"国籍"+s1.country);
        System.out.println("姓名"+s2.country+"国籍"+s2.country);
    }
    
}

static修饰函数(静态函数)

注意:

• 可以类名进行访问
• 静态函数不可出现this和super关键字

super关键字

super关键字是调用父类空间的引用

注意:

• 子父类同名成员,super可调用父类的成员
• 指定调用父类的带参构造方法
• super默认在子类无参构造方法中,调用父类无参构造方法

instanceof 关键字

**作用:**判断对象是否属于指定类别

注意:

• 判断的对象与指定的类被必须要存在继承或者实现关系

final关键字

注意:

• 修饰的基本类型的变量时,该变量不可再次赋值
• 修饰的时候必须赋予初始值
• 修饰函数的时候不能被重新
• 修饰类的时候,该类不可被继承

抽象类

**应用场景: ** 一类事物存在这,某种不具体的行为

注意:

• abstract修饰抽象类

• abstract不可以和private同时使用

• abstract不可以和static共同修饰

• abstract不可以和final共同修饰

• 使用abstract修饰抽象函数

• 非抽象类在继承抽象类时,要实现所有的抽象函数

接口

interface 接口是一个特殊的类

注意:

• 接口中的成员变量都是常量,默认修饰符 public static final
• 接口是一个特殊的类
• 接口不能创建对象
• 接口不可以构造方法
• 接口中的方法都是抽象方法,默认修饰符为absteact

内部类

成员内部类

应用场景:

和继承类似,优先考虑内部类

访问格式：

1. 外部类.内部类 变量名 = new 外部类().new 内部类();

注意:

• 外部类和内部类存在同名的成员变量的时候,默认访问内部类的成员变量,可通过 外部类.this.成员变量名指定访问外部类成员。

局部内部类

注意：

• 局部内部类访问一个局部变量，那么该局部变量必须使用final修饰

匿名内部类

应用场景:

• 实参传递

• class Demo1 
  {
  	public static void main(String[] args) 
  	{
  		test(new Dao(){
  			public void add(){
  				System.out.println("第一个抽象方法");
  			}
  			public void pdd(){
  				System.out.println("第二个抽象方法");
  			}
  		});//匿名内部类做实参使用;
  	}
  	//调用这个方法
  	public static void test(Dao d)
  	{
  		d.add();
  		d.pdd();
  	}
  }
  

**定义：**没有类名的类

注意：

• 前提必须存在继承或者实现关系
• 格式：在公共方法内部创建 new 父类{成员}.方法名

异常

自定义异常类

自定义一个类继承Exception

构造方法

public 类名（String s）{

​ super（s）；

}

RuntimeException为运行时异常，可声明也可以不声明。其他的都是编译行异常，必须声明和处理。

finally块

前提必须有try块

finally块是在任何情况下都可以执行，可以用作释放资源。

JAVAAPI

字符串

注意：

• 使用equals方法时，使用 ==“常量” .equals(“变量”)==可以避免出现空指针异常

笔试题目：new String(“abc”)创建了几个对象？
两个对象， 一个对象是 位于字符串常量池中，一个对象是位于堆内存中。

字符串方法

String 的构造方法

String() 创建一个空内容 的字符串对象。
String(byte[] bytes) 使用一个字节数组构建一个字符串对象
String(byte[] bytes, int offset, int length)
bytes : 要解码的数组
offset： 指定从数组中那个索引值开始解码。
length：　要解码多个元素。

获取方法

​ int length() 获取字符串的长度
​ char charAt(int index) 获取特定位置的字符 (角标越界)
​ int indexOf(String str) 查找子串第一次出现的索引值,如果子串没有出现 在字符串中，那么则返回-1表示。
​ int lastIndexOf(String str) 查找子串最后一次出现的索引值 , 如果子串没有出现 在字符串中，那么则返回-1表示

判断方法

​ boolean endsWith(String str) 是否以指定字符结束
​ boolean isEmpty()是否长度为0 如：“” null V1.6
​ boolean contains(CharSequences) 是否包含指定序列 应用：搜索
​ boolean equals(Object anObject) 是否相等
​ boolean equalsIgnoreCase(String anotherString) 忽略大小写是否相等

转换方法

char[] toCharArray() 将字符串转换为字符数组
byte[] getBytes();

new String(byte[] bytes||char[] char) 使用一个字节数组构建一个字符串对象

字节数组与字符数组、字符串他们三者之间是可以互相转换。

其他方法

其他方法
String replace(String oldChar, String newChar) 替换
String[] split(String regex) 切割

String substring(int beginIndex) 指定开始 的索引值截取子串
String substring(int beginIndex, int endIndex)指定开始 与结束的索引值截取子串

String toUpperCase() 转大写
String toLowerCase() 转小写
String trim() 去除字符串首尾的空格

StringBuffer

注意:

• 字符串是常量,他们的值创建之后不能修改
• StringBuffer底层维护的字符数组,初始容量16,动态扩容1倍

方法:

增加

append(boolean b) 可以参加任意类型的数据

inster(int offset, boolean b) 指定插入的索引值，插入对应的内容

删除

delete(int start，int end) 根据只当的开始与结束的索引值删除对应的内容。

deleteCharAt(int index)根据指定的索引值删除一个字符。

修改

replace(int start, int end,String str) 根据指定的开始与技术索引值替代成指定的内容。

reverse()反转字符串的内容 abc—>cba

setCharAt(int index， char ch) 指定索引字符替换一个字符

substring(int start,int end)指定的索引值截取子串

ensureCaoacity(int minimumCaoacity)指定StringBuffer内部的字符数组长度的。

查看

toString() 将字符串缓冲类的内容转换成字符串返回

indexOf(String str,int fromIndex) 查找指定的字符串第一次出现的索引值，并且指定开始查找的位置。

capacity()查看当前字符数组的长度

length()

charAt(int index)

lastIndexof(String str)

System

currentTimeMillis() 获取当前系统时间。 重点掌握

Date类

=Date data = new Data()获取当前系统时间

Calendar类

日期格式化类 SimpleDateFormat

SimpleDateFormat作用:

作用1： 可以把日期转换转指定格式的字符串 format()
作用2： 可以把一个 字符转换成对应的日期。 parse() 生日

        Date date = new Date();//获取当前系统时间。        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");//使用了默认的格格式创建了一个日期格式        String time  = dateFormat.format(date);//日期转换成之情格式的字符串        System.out.println(time);        String bithday = "2000年11月12日 11:24:04";        Date date1 = dateFormat.parse(bithday);//字符转换成对应的日期        //注意指定的字符串格式必须要与SimpleDataFormat一致        System.out.println(date1);

Math数学类

Math 数学类， 主要是提供了很多的数学公式。

abs(double a) 获取绝对值
ceil(double a) 向上取整
floor(double a) 向下取整
round(float a) 四舍五入
random() 产生一个随机数. 大于等于 0.0 且小于 1.0 的伪随机 double 值

随机数类Random

Random random = new Random();

int randomNum = random.nextInt(11);//产生随机数0-10

多线程

创建线程的方法：

方法：

sleep()方法是静态方法,sleep在哪里运行,就是哪个线程睡眠

sleep不可捕获处理

 public static void main(String[] args) { 	new 自定义线程类 . sleep()   }  public void run{  }

这里线程是主方法线程睡眠,因为在主线程调用了sleep,与哪个对象调用无关

同步机制

同步代码块:

• synchronized(锁){ 需要被同步的代码 }
• 锁对象必须是共享唯一的

同步函数:

• 使用synchronized修饰函数

创建多线程方法一

• 继承Thread
• 重新run方法
• 自定义线程的任务代码写在run方法中
• 调用start方法启动

创建多线程方法二

1. 自定义一个类实现Runnable接口。

2. 实现Runnable接口 的run方法，把自定义线程的任务定义在run方法上。

3. 创建Runnable实现类对象。

4. 创建Thread类 的对象，并且把Runnable实现类的对象作为实参传递。

5. 调用Thread对象 的start方法开启一个线程。

正则表达式

应用场景:

**匹配:**matches

**切割:**split

**替换:**replaceAll

查询:

jdk新特性

增强for循环

注意：

• 迭代器遍历集合元素可以it.remov删除元素,但是foreach不可以

可变参数

注意:

• 数据类型 … 变量名
• 实际是一个数组
• 必须放到最后一个位置

自动装箱和拆箱

Integer类

里面含有缓存 相当于-128~~127的数组

枚举

**定义:**一些方法运行时,它需要的数据不能是任意的,必须是一定范围内的值;比如性别的设定

格式:

eum 类名{

​ 枚举值

}

注意:

• 枚举值默认为public static final
• 枚举值实现了本类的对象

IO流

File类

创建：

createNewFile() 在指定位置创建一个空文件，成功就返回true，如果已存在就不创建然后返回false
mkdir() 在指定位置创建目录，这只会创建最后一级目录，如果上级目录不存在就抛异常。
mkdirs() 创建多级文件。
renameTo(File dest) 如果目标文件与源文件是在同一个路径下，那么renameTo的作用是重命名， 如果目标文件与源文件不是在同一个路径下，那么renameTo的作用就是剪切，而且还不能操作文件夹。

删除

delete() 删除文件或一个空文件夹，如果是文件夹且不为空，则不能删除，成功返回true，失败返回false。
deleteOnExit() jvm退出的时候删除文件。 一般用于删除临时 文件。

判断

exists() 文件或文件夹是否存在。
isFile() 是否是一个文件，如果不存在，则始终为false。
isDirectory() 是否是一个目录，如果不存在，则始终为false。
isHidden() 是否是一个隐藏的文件或是否是隐藏的目录。
isAbsolute() 测试此抽象路径名是否为绝对路径名。

获取
getName() 获取文件或文件夹的名称，不包含上级路径。
getPath() 返回绝对路径，可以是相对路径，但是目录要指定
getAbsolutePath() 获取文件的绝对路径，与文件是否存在没关系
length() 获取文件的大小（字节数），如果文件不存在则返回0L，如果是文件夹也返回0L。
getParent() 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回null。
lastModified() 获取最后一次被修改的时间。

文件夹相关

staic File[] listRoots() 列出所有的根目录（Window中就是所有系统的盘符）
list() 返回目录下的文件或者目录名，包含隐藏文件。对于文件这样操作会返回null。
listFiles() 返回目录下的文件或者目录对象（File类实例），包含隐藏文件。对于文件这样操作会返回null。
list(FilenameFilter filter) 返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null。
listFiles(FilenameFilter filter) 返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null。

设计模式

单例设计模式

定义:保证一个类在内存中只有一个对象

推荐:饿汉,不存在线程安全

饿汉步骤:

1. 私有化构造函数
2. 声明本类的引用类型变量,并且使用该变量指向本类对象
3. 提供一个公共静态方法获取本类的对象

package Test;class Single{//    私有化静态变量指向对象    private static Single s = new Single();    //私有化构造函数    private Single(){    }//  提供公共方法获取变量    public static Single getInstance(){        return  s;    }}public class Demo2 {    public static void main(String[] args) {        Single instance1 = Single.getInstance();        Single instance2 = Single.getInstance();        System.out.println(instance1==instance2);    }}

懒汉步骤:

1. 私有化构造函数
2. 声明本类的引用类型变量,但不创建对象.
3. 提供公共静态方法,判断是否创建本类对象,没创建就创建一个.

package Test;class Single{    private static Single s;    //私有化构造函数    private Single(){    }    public static Single getInstance(){        if (s == null){            s = new Single();        }        return s;    }}public class Demo2 {    public static void main(String[] args) {        Single instance1 = Single.getInstance();        Single instance2 = Single.getInstance();        System.out.println(instance1==instance2);    }}

模板模式

**定义：**某类事情的步骤有些事固定的，有些是会发生变化的，那么这时候我们可以为这类事情提供一个模板代码，从而提高效率。

模板模式的步骤：

1. 先写出解决该类事情其中一件解决方案 。

2. 分析代码，把会发生变化的代码抽取出来独立成一个方法。把该方法描述成一个抽象的方法。

3. 使用final修饰模板方法，防止别人重写你的模板方法。

   abstract class MyRuntime{		public final void getTime(){		long startTime = System.currentTimeMillis();	//记录开始的时间		code();		long endTime = System.currentTimeMillis();  //记录结束的时间.		System.out.println("运行时间 ："+ (endTime-startTime));	}	public abstract void code();}class Demo11 extends MyRuntime{	public static void main(String[] args) 	{		Demo11 d = new Demo11();		d.getTime();	}		//code方法内部就写要计算运行时间 的代码；	public  void code(){		int i = 0;		while(i<100){			System.out.println("i="+i);			i++;		}	}}
   

标签：java,复习,int,void,笔记,对象,static,public,String
来源： https://blog.csdn.net/qq_35605819/article/details/120402705

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。