全部栏目

首页 操作系统 后端开发 数据库 前端开发 移动端开发
您的当前位置：首页正文

day18_补充01

2024-11-10 来源：个人技术集锦

1 自增自减混合运算

System.out.println(1+2+3/2+3+1*4+5);//从左到右 运算符有优先级

int a,b;
a=1;
a++;//a=(int)(a+1);
System.out.println("a="+a);
a=1;
++a;//a=(int)(a+1);
System.out.println("a="+a);

//++带复制
a=1;
b=++a;//等价于 a=(int)(a+1);b=a;
System.out.println("a="+a+",b="+b);//a=2 b=2
a=1;
b=a++;//等价于 b=a;a=(int)(a+1);
System.out.println("a="+a+",b="+b);//a=2 b=1

a=1;// a=3
b=(a++)+a+(++a)/(a--)+(a++);
//b= 1+2+3/3+2;
System.out.println("a="+a+",b="+b);
//总结：++在前 先自增 拿自增后的值 参加本次运算
//     ++在后 拿当前值参加本次运算 然后再自增

a=1;
a=++a;//2
System.out.println("a="+a);
a=1;
a=a++;//1  等价于：int k=a; a++;  a=k;
System.out.println("a="+a);

2 内部类

内部类：在类中定义的类 称为内部类
       如果a类的存在 依赖b类的存在而存在时 可以把a类定义为b类的内部类
内部类：a类
外部类：b类

2.1 成员内部类

内部类是外部类的实例成员

public class BuChong02_01InstanceInner {

	public static void main(String[] args) {
		//创建成员内部类对象：实例成员 只能通过对象调用
		//必须通过外部类对象来创建成员内部类对象
		Outer01 o1=new Outer01();
		Outer01.Inner01 i1=o1.new Inner01();
		Outer01.Inner01 i2=new Outer01().new Inner01();
		i2.show();

	}
}
class Outer01{//外部类
	String name="外部类成员变量_name";//外部类实例成员变量
	int a=1;
	class Inner01{//成员内部类
		String name="内部类成员变量_name";//内部类实例成员变量
		void show() {//内部类的实例方法
			String name="内部类局部变量_name";
			System.out.println("a="+a);
			System.out.println("内部类的局部变量：name="+name);
			System.out.println("内部类的成员变量：this.name="+this.name);
			System.out.println("外部类的成员变量：Outer01.this.name="+Outer01.this.name);
		}
	}
}

2.2 静态内部类

内部类是外部类的静态成员

public class BuChong02_02StaticInner {

	public static void main(String[] args) {
		//静态内部类：内部类是外部类的静态成员
		Outer02.Inner02 i1;
		i1=new Outer02.Inner02();
		i1.show();
	}
}
class Outer02{//外部类
	String name="外部类成员变量_name";//外部类实例成员变量
	static int b=2;
	static class Inner02{//静态内部类
		String name="内部类成员变量_name";//内部类实例成员变量
		void show() {//内部类的实例方法
			System.out.println("b="+b);//只能调用外部类的静态成员
		}
	}
}

2.3 局部内部类

内部类定义在外部类的方法体或者代码块中

public class BuChong02_03PartInner {
	/*
	 * 局部内部类：内部类定义在外部类的方法体/代码块中
	 * */
	public static void main(String[] args) {
		new Outer03().show();
	}

}
class Outer03{
	String name="外部类成员变量_name";//外部类实例成员变量
	void show() {
		String name="外部类方法局部变量_name";//外部类方法局部变量
		class Inner03{
			String name="局部内部类成员变量_name";
			void showInner() {
				String name="局部内部类方法的局部变量_name";
				System.out.println("name="+name);
				System.out.println("this.name="+this.name);
			}
		}
		//局部内部类 只能在当前大括号内创建对象
		Inner03 i3=new Inner03();
		i3.showInner();
	}
}

2.4 匿名内部类

匿名的局部内部类

public class BuChong02_04AnonymousInner {
    /*匿名内部类：没有名字的局部内部类
     * */
	public static void main(String[] args) {
		Test04 t1=new Test04Imp();
		t1.hehe();
		
		//使用接口方法2：通过局部内部类实现
		class Inner041 implements Test04{
			public void hehe() {
				System.out.println("局部内部类的hehe方法");
			}
		}
		
		Test04 t2=new Inner041();
		t2.hehe();
		t2=new Inner041();
		t2.hehe();
		
		//使用接口方法3：通过匿名局部内部类实现  (此局部内部类只使用一次)
		Test04 t3=new Test04() {
			public void hehe() {
				System.out.println("匿名内部类的hehe方法");
			}
		};
		t3.hehe();

	}
}
interface Test04{
	void hehe();
}
//使用接口方法1：创建一个实现类 实现其抽象方法 通过是实现类的对象 调用方法
class Test04Imp implements Test04{
	public void hehe() {
		System.out.println("实现类的hehe方法");
	}
}

3 设计模式

javase有23种设计模式：
   在javase开发过程中 java大师总结的23种用于解决常见问题的固定套路(模板代码)

参考：https://www.runoob.com/design-pattern/adapter-pattern.html

参考：https://www.cnblogs.com/fengmo2427/p/16130648.html

3.1 分类

创建型模式：对象实例化的模式，创建型模式用于解耦对象的实例化过程。

结构型模式：把类或对象结合在一起形成一个更大的结构。

行为型模式：类和对象如何交互，及划分责任和算法。

3.2 单例模式

单例模式：一个类只能有一个对象

package day19_socket_other;

public class Demo01Single {
    /*单例模式：一个类只允许创建一个对象
     * */
	public static void main(String[] args) {
		Singleton01 s1=Singleton01.getInstance();
		Singleton01 s2=Singleton01.getInstance();
		System.out.println(s1==s2);

	}

}
//饿汉模式：类一加载 对象就创建
class Singleton01{
	//1 不能让调用者 创建对象：私有化构造器
	private Singleton01() {}
	//2 定义静态方法创建当前类的对象
	public static Singleton01  getInstance() {
		return s;
	}
	//3 定义静态成员变量记录唯一的对象
	private static Singleton01 s=new Singleton01();
}
//懒汉模式：方法第一次被调用时 才创建对象
class Singleton02{
	//1 不能让调用者 创建对象：私有化构造器
	private Singleton02() {}
	//2 定义静态方法创建当前类的对象
	public static Singleton02  getInstance() {
		if(s==null) {
			s=new Singleton02();//当前方法第一次被调用时 创建此唯一对象
		}
		return s;
	}
	//3 定义静态成员变量记录唯一的对象
	private static Singleton02 s;
}

//线程安全的懒汉模式
class Singleton03{
	//1 不能让调用者 创建对象：私有化构造器
	private Singleton03() {}
	//2 定义静态方法创建当前类的对象
	public synchronized static Singleton03  getInstance() {
		if(s==null) {
			s=new Singleton03();//当前方法第一次被调用时 创建此唯一对象
		}
		return s;
	}
	//3 定义静态成员变量记录唯一的对象
	private static Singleton03 s;
}

3.3 工厂模式

把对象的创建 交给工厂类的方法来实现

实例工厂模式

创建对象的方法是工厂的实例方法

静态工厂模式

创建对象的方法是工厂的静态方法

public class Demo02Factory {
   public static void main(String[] args) {
	   //实例工厂模式
	   Demo02 d1=new DemoFactory01().getInstance();
	   Demo02 d2=DemoFactory02.getInstance();
   }
}

class Demo02{}
//Demo02类对象的创建 交给工厂类的方法来实现
//实例工厂模式
class DemoFactory01{
	public Demo02 getInstance() {
		return new Demo02();
	}
}
//静态工厂模式
class DemoFactory02{
	public static Demo02 getInstance() {
		return new Demo02();
	}
}

4 枚举

枚举是一种特殊的类：多例类：：一个类有固定的几个对象
比如：方向 ，颜色， 类型

4.1 通过类实现多例

//通过类实现多例
class Demo03Class{
	//属性
	private String name;
	//构造方法
	private Demo03Class(String name) {this.name=name;}
	//四个实例
	 private static final Demo03Class up=new Demo03Class("向上");
	 public static Demo03Class getInstanceUp() {
		 return up;
	 }
	 private static  final Demo03Class down=new Demo03Class("向下");
	 public static Demo03Class getInstanceDown() {
		 return down;
	 }
	 private static final Demo03Class left=new Demo03Class("向左");;
	 public static Demo03Class getInstanceLeft() {
		 return left;
	 }
	 private static  final Demo03Class right=new Demo03Class("向右");;
	 public static Demo03Class getInstanceRight() {
		 return right;
	 }
	 //普通方法
	public String getName() {
		return name;
	}
	 
}

4.2 定义枚举

//通过枚举实现：关键字enum
enum Demo03Enum{
	//定义实例:static final
	UP("向上"),DOWN("向下"),LEFT("向左"),RIGHT("向右");//定义实例的对象之间必须用，分割 必须是第一个语句
	//定义属性
	private String fangXiang;
	//构造方法
	private Demo03Enum(String fangXiang){this.fangXiang=fangXiang;}
	//普通方法
	public String getFangXiang() {
		return fangXiang;
	}
}

4.3 枚举使用switch

//switch(1.1) {}// Only convertible int values, strings or enum variables are permitted
//枚举可以被switch进行操作
switch(e1) {
    case UP://注意：case 后面的枚举对象不用加类名
        System.out.println("up");
        break;
    case DOWN:
        System.out.println("down");
        break;
    case LEFT:
        System.out.println("left");
        break;
    case RIGHT:
        System.out.println("right");
        break;
}

4.4 枚举继承类：java.lang.Enum

Demo03Enum e1=Demo03Enum.UP;
Demo03Enum e2=Demo03Enum.DOWN;
Demo03Enum e3=Demo03Enum.LEFT;

//所有枚举继承java.lang.Enum  
//1 int compareTo(E o)  :比较的是对象的下标
//2 boolean equals(Object other)  
//3 int ordinal() :获取当前对象的顺序：从0开始
//4 String name()  :获取实例名称
//5 static T valueOf(Class<T> enumType, String name) :获取指定名字的实例对象
System.out.println("e1.ordinal()="+e1.ordinal());
System.out.println("e2.ordinal()="+e2.ordinal());
System.out.println("e1.name()="+e1.name());
System.out.println("e2.name()="+e2.name());
System.out.println(Demo03Enum.valueOf(Demo03Enum.class, "UP").getFangXiang());
System.out.println(e1.compareTo(e2));

4.5 枚举自带的方法

//枚举类自带的方法
// static T  valueOf(String name);获取参数名对应的对象
// static T[]  values();获取所有对象
System.out.println(Demo03Enum.valueOf("UP"));
System.out.println(Arrays.toString(Demo03Enum.values()));

4.6 枚举种可以定义抽象方法

//通过枚举实现：关键字enum
enum Demo03Enum{
	//定义实例:static final
	UP("向上"){
		public  void hehe() {
			System.out.println("up....hehe");
		}
	},DOWN("向下"){
		public  void hehe() {
			System.out.println("down....hehe");
		}
	},LEFT("向左"){
		public  void hehe() {
			System.out.println("left....hehe");
		}
	},RIGHT("向右"){
		public  void hehe() {
			System.out.println("right....hehe");
		}
	};
	//定义属性
	private String fangXiang;
	//构造方法
	private Demo03Enum(String fangXiang){this.fangXiang=fangXiang;}
	//普通方法
	public String getFangXiang() {
		return fangXiang;
	}
	//枚举种定义抽象方法
	public abstract void hehe();
}

5 1.8新特性

5.1 不定参数

public static void main(String[] args) {
    // TODO Auto-generated method stub
    test01(new int[] {1,2,3,4});
    test02(new int[] {1,2,3,4});//不定参数可以传递一个数组
    test02(1,2,3,4);//不定参数可以传递多个数据
    test02();//可以不传递参数
}
//不定参数：：定义方法参数列表时：通过..表示指定类型的>=0个的参数：起始就是一个数组
public static void test01(int[] arr) {
    System.out.println(arr);
}
public static void test02(int...a) {//[I@4e25154f
    System.out.println(a);
}
//注意事项：多个参数时：不定参数必须是最后个参数
public static void test03(float f,int a) {//[I@4e25154f
    System.out.println(a);
}

5.2 接口中可以定义静态和默认方法

package day19_socket_other;

public class Demo04 {
    
	public static void main(String[] args) {
         MyInter04 i1=new MyInter04() {
        	 public void show() {}
         };
         i1.hai();
         MyInter04 i2=new MyInter04() {
        	 public void show() {}
        	 public void hai() {
        			System.out.println("重写hai方法");
        	 }
         };
         i2.hai();
         
	}
}

//接口中可以定义静态方法和默认方法
interface MyInter04{
	void show();
	//可以有默认方法：实现类可以选择重写默认方法 如果不重写 就使用接口中定义的
	default void hai() {
		System.out.println("默认方法");
	}
	//可以有静态方法
	static void hehe() {}
}

5.3 Lambda表达式

package day19_socket_other;

public class Demo05 {
    /*lambda表达式：对匿名内部类的简写方式
     * 
     * */
	public static void main(String[] args) {
		//内部类
		class MyInter05Inner implements MyInter05{
			public void hehe() {}
		}
		new MyInter05Inner().hehe();
		// 匿名内部类
		MyInter05 i1=new MyInter05() {
			public void hehe() {}
		};
		i1.hehe();
		//lambda表达式:要求要实现的接口或者抽象类只能有一个抽象方法
		MyInter05 i2=()->{
			System.out.println("lambda表达式1");
		};
		//1:方法体只有一个语句：{}可以省略
		MyInter05 i3=() -> System.out.println("lambda表达式1");
		i2.hehe();
		//2：有参数： 参数类型可以省略
		MyInter051 i11=(int a,int b) -> System.out.println(a+":"+b);
		i11.hehe(1, 2);
		MyInter051 i12=(b, c) -> System.out.println(b+":"+c);
		i12.hehe(1, 2);
        //3: 有返回值值：
		MyInter052 i21=(int a,int b) -> {System.out.println(a+":"+b);return a+b;};
		i21.hehe(1, 2);
		MyInter052 i22=(int a,int b) -> {return a+b;};
		i22.hehe(1, 2);
		//  只有一个语句 并且是return时  return可以省略
		MyInter052 i23=(int a,int b) -> a+b;
		i23.hehe(1, 2);
		MyInter052 i24=(a,b) -> a+b;
	}
}
interface MyInter05{
	void hehe();
}
interface MyInter051{
	void hehe(int a,int b);
}
interface MyInter052{
	int hehe(int a,int b);
}
  • 参考https:///weixin_40294256/article/details/126338618

5.4 Optinal:判断对象是不是null

Optional o1=Optional.of("abc");
System.out.println("o1.get() 获取关联的对象="+o1.get());
System.out.println("o1.isPresent() 判断关联的对象是不是不是kong的="+o1.isPresent());
o1=Optional.empty();//创建一个空的Optional对象
System.out.println(o1.isPresent());

System.out.println("o1.orElse(cba) 判断当前对象是否为空 如果为空返回参数对象 如果不为空返回当前对象 ="+o1.orElse("cba"));
o1=Optional.of("abc");
System.out.println("o1.orElse(cba) ="+o1.orElse("cba"));

6 正则表达式7

概念

/*
     * 正则：为字符串的匹配定义正确的规则
     * 表达式：用于计算数据的式子：
     *
     *使用一些特殊字符来表示规则：
         *1 表示范围：使用[]
         *  [abc] : 表示可以选择a/b/c中的一个
         *  [a-d] : 表示可以选择a到d之间的任意一个字符---针对的是编码表
         *  [^a-d] : 表示除了a到d之间的其他所有字符 
         *  [a-c[e-z]] 等价于[a-ce-z] 取并集
         *  [a-y&&[b-z]] 等价于[b-y] 取交集
         *2 表示次数：使用{}
         *   a{n}  : a出现n次：
         *   a{n,} : a出现>=n次：
         *   a{n,m} : a出现>=n次 <=m次
         *   a+   : a出现>=1次
         *   a?   : a出现<=1次
         *   a*   : a出现>=0次
         * 3 特殊字符：
         *    .  ： 表示任意字符
         *    x  ： 表示x字符
         *    \\. ： 表示.字符
         *    ^   : 字符串开头
         *    $   : 字符串结尾
         *    \d 数字：[0-9] 
         *    \D 非数字： [^0-9] 
         *    \s 空白字符：[ \t\n\x0B\f\r] 
         *    \S 非空白字符：[^\s] 
         *    \w 单词字符：[a-zA-Z_0-9] 
         *    \W 非单词字符：[^\w] 
     * 
     * 可以使用正则表达式的方法：
         * boolean matches(String regex) 
         * String[] split(String regex)   
         * String replaceAll(String regex, String replacement)  
     * */

案例

public static void main(String[] args) {
    testMatches();
    testSplit();
    testReplaceAll();
}
public static void testReplaceAll() {
    //删除其中的所有数字
    System.out.println("12abc34jyt98pkkkk04".replaceAll("[0-9]+", ""));
    System.out.println("12abc34jyt98pkkkk04".replaceAll("\\d+", ""));

    //替换所有的叠词为*
    System.out.println("abc111bcccdiiio999".replaceAll("(.)\\1+", "*"));
    //替换所有的叠词为字符abc111bcccdiiio999-->abc1bcdio9
    // replaceAll中的第二个参数 $1 表示第一个正则参数的第一组的内容
    System.out.println("abc111bcccdiiio999".replaceAll("(.)\\1+", "$1"));

    //替换所有a*a为*   121343abaiioii---24bo
    System.out.println("121343abaiioii".replaceAll("((.)\\2*)(.)\\1", "$3"));
}
public static void testSplit() {
    //使用.切割
    System.out.println(Arrays.toString("12.34.5.67.8".split(".")));
    System.out.println(Arrays.toString("12.34.5.67.8".split("\\.")));

    //12abc34jyt98pkkkk04 把其中的连续的数字拿出来：12  34 98 04
    System.out.println(Arrays.toString("12abc34jyt98pkkkk04".split("[^0-9]+")));

    //abc111bcccdiiio999  使用叠词切割：abc b  d  o
    System.out.println(Arrays.toString("abc111bcccdiiio999".split("(.)\\1+")));

    //abcBddcB98bbDytBcd  使用b和B切割
    System.out.println(Arrays.toString("abcBddcB98bbDytBcd".split("[bB]+")));
}

public static void testMatches() {
    //使用正则表示:用户名：以字母开头 由数字 字母组成 长度6-8位
    String pattern="[a-zA-Z][a-zA-Z0-9]{5,7}";
    String name="abc1234";
    System.out.println(name+":::"+name.matches(pattern));
    name="abc1234_";
    System.out.println(name+":::"+name.matches(pattern));

    //使用正则表示:邮箱地址：miaotianbao@163.com
    // 用户名@域名：：：域名有后缀
    pattern="[0-9a-zA-Z_]+@[0-9a-zA-Z_]+(\\.[a-z]+)+";
    //[0-9a-zA-Z_]+   表示用户名
    // @              表示@符
    //[0-9a-zA-Z_]+   表示主机名
    //\\.[a-z]+   表示一个后缀
    //(\\.[a-z]+)+ 表示>=1个后缀
    String email="abc1234_@1.com.cn";
    System.out.println(email+":::"+email.matches(pattern));
    
    
    //使用正则表示中文名字:
    //汉字正则： [\u4e00-\u9fa5]
    pattern="[\u4e00-\u9fa5]{2,4}";
    name="张三丰a";
    System.out.println(name+":::"+name.matches(pattern));

    //使用正则表示叠词：aaaa bb  cccc
    pattern="^(.)\\1+$";
    String str="aa";
    System.out.println(str+":::"+str.matches(pattern));
    str="aaa";
    System.out.println(str+":::"+str.matches(pattern));
    str="aaab";
    System.out.println(str+":::"+str.matches(pattern));

    //使用正则表示叠词：aaabb  aaaabbbbb   ccc11
    pattern="^(.)\\1+(.)\\2+$";
    str="aaabb";
    System.out.println(str+":::"+str.matches(pattern));

    //使用正则表示叠词：abab  1212 3434 
    pattern="^(..)\\1$";
    pattern="^(.)(.)\\1\\2$";
    str="abab";
    System.out.println(str+":::"+str.matches(pattern));

}
//使用正则表示电话号码
public static boolean pdPhone2(String phone) {
    //使用正则判断phone是否与电话号码规则匹配
    String pattern="1[3-9][0-9]{9}";
    return phone.matches(pattern);
}

7 LinkedList
显示全文