String类、泛型、权限修饰符

1.String

1.1String的两种声明方式

public class Demo1 {
	public static void main(String[] args) {
		
		//声明的第一种方式:
		String string = "我欲乘风归去";
		System.out.println(string);
		//这第二种声明方式
		String str1 = new String("goudan");
		System.out.println(str1);
	}
}

1.2两个字符串比较

== ： 比较 是内存的地址 比较严格的

equlas: 先比较地址，然后地址不一样再比较内容。开发中 比较两个字符串一定使用equals

public class Demo2 {
	public static void main(String[] args) {
		
		String str1 = "abc";
		String str2 = "abc";
		String str3 = new String("abc");
		String str4 = new String("abc");
		
		//==   比较的是内存的地址 
		System.out.println(str1 == str2);//true
		System.out.println(str1 == str3);//false
		System.out.println(str3 == str4);//false
		
		// boolean equals(Object anOnject);  比较两个字符串是否相等
		//equals  先比较的是内存地址，如果内存地址一样  肯定是一样的。如果地址不一样 再比较内容 
		//内容一样的话，也true
		System.out.println(str1.equals(str2));//true
		System.out.println(str1.equals(str3));//true
		System.out.println(str3.equals(str4));//true
		/**
		 * "abc" a   "abc"b
		 *   a == b  内存不一样 false
		 *   继续比较内容
		 *   a = {'a', 'b', 'c'}   b = {'a', 'b', 'c'};
		 *   for () {
		 *   	if (a[i] == b[i]) {
		 *   		a[0] == b[0]
		 *   		a[1] ==b[1]
		 *   		a[2] == b[2]
		 *   	}
		 *   	
		 *   }
		 * public boolean equals(Object anObject) {
        if (this == anObject) {//比较两个内存地址是否一样
            return true;//内存地址一样的话就返回true
        }
        if (anObject instanceof String) {//true
            String anotherString = (String)anObject; 强转为字符串
            	v1 = {'a', 'b', 'c'}   v2 = {'a', 'b', 'c'};
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                		
                    if (v1[i] != v2[i]) {
                    	v1[0] !=v2[0]
                    	v1[1] !=v2[1]
                    	v1[2] !=v2[2]
                        return false;
                        }
                    i++;
                }
                return true;
            }
        }
        return false;
    }
		 *   
		 */
		
	}
}

1.3关于String类I型数据的内存分析

String str = "hello";
String str2 = "hello";
String str3 = new String("hello");
worldhello

1.4String类下面的方法

获取字符串长度 int length();

获取特定位置的字符 char charAt(int index);

获取特定字符的下标 int indexOf(String str);

获取特定字符的最后的一个位置 int lastIndexOf(int ch);

public class Demo3 {
	public static void main(String[] args) {
		String str1 =  "中国梦";
		System.out.println(str1.length());//6
		
		String str2 = "abcdef";
		System.out.println(str2.charAt(3));//找str2字符串中下标为 0位置的上的字符
		
		
		String str3 = "abcdecvf";
		
		System.out.println(str3.indexOf("cd"));//获取的是字符的下标
		System.out.println(str3.indexOf(98));//1
		System.out.println(str3.indexOf('c'));//2
		System.out.println(str3.lastIndexOf('c'));//5
		
		
		
		
	}
}

返回值是布尔类型数据

boolean endWith(String str); 是否以指定的字符或者字符串结尾

boolean isEmpty();判断是否为空，如果字符串为空就 true

boolean contains(); 判断是否包含子字符串

boolean equals(Object anOnject); 判断两个字符串是否相等

boolean equalsIgnoreCase(Object anObject); 忽略大小写判断两个字符串是否相等

public class Demo4 {
	public static void main(String[] args) {
		
		String str1 = "Demo1.java";
		System.out.println(str1.endsWith(".java"));//true
		System.out.println(str1.endsWith("av"));//false
		System.out.println(str1.endsWith("va"));//true
		
		
		String str2 = "";
		System.out.println(str2.isEmpty());//true
		String str3 = " ";
		System.out.println(str3.isEmpty());//flase  不为空 空格也是有内容的
		
		
		String str4 = "abcdef";
		System.out.println(str4.contains("cd"));//true
		System.out.println(str4.contains("ce"));//false
		System.out.println(str4.contains("abcde"));//true
		
		System.out.println(str4.equals("abcdeF"));//false
		
		System.out.println(str4.equalsIgnoreCase("abcDeF"));//true
		
		
	}
}

将字符数组转为字符串

直接可以使用STring类的构造方法

String(char[] value)

String(char[] value, int offset, int count)

static String valueOf(char[] chs);

将字符串转为字符数组

char[] toCharArray();

public class Demo5 {
	public static void main(String[] args) {
		
		//将字符数组转为字符串
		char[] chs = {'a', 'b', 'c', 'd', 'e'};
		String str = new String(chs);
		System.out.println(str);//abc
		//String(char[] chs, int offset, int count);  
		//第二个参数  int  offset  偏移量 从第几个开始
		//第三个参数 int  count   个数 数量
		String str1 = new String(chs, 4, 1);
		System.out.println(str1);
		
		String str2 = String.valueOf(chs);
		System.out.println(str2);
		
		
		//将字符串转为字符数组
		char[] arr1 = "狗蛋很狗".toCharArray();
		for (int i = 0; i < arr1.length; i++) {
			System.out.println(arr1[i]);
		}
		
	}
}	

以下是几个比较重要的方法

String replace(char oldChar, char newChar); 字符在字符串中替换

String [] split(String regex); 以 regex 对当前的字符串进行切割

String subString(int beginIndex); 截取字符串一部分

String subString(int beginIndex， int endIndex); 截取字符串一部分

String toUpperCase();将小写字母转为大写的字母

String toLowerCase();将大写转为小写字母

String trim(); 去除左右空格

import java.util.Arrays;

public class Demo6 {
	public static void main(String[] args) {
		
		String str = "abcdef";
		System.out.println(str.replace('c', '中'));
		System.out.println(str.replace("cd", "牛彩云"));
		
		
		String str1 = "嘻嘻哒呵呵哒么么哒哈哈哒";
		//以哒切割
		String[] strs = str1.split("哒");
		System.out.println(strs);
		System.out.println(Arrays.toString(strs));//[嘻嘻, 呵呵, 么么, 哈哈]
		
		for (int i = 0; i < strs.length; i++) {
			System.out.println(strs[i]);
		}
		
		String str2 = "ab,cd,ef,g";
		//以,  切割
		String[] strs1 = str2.split(",");
		System.out.println(Arrays.toString(strs1));
		
		
		//截取一部分的字符串
		String str3 = "abcdef";
		System.out.println(str3.substring(2));//cdef
		
		
		String str4 = "大学先把手机农村";
		System.out.println(str4.substring(2, 4));// 先把//要头不要尾
		
		
		
		String str5 = "abCDF";
		System.out.println(str5.toUpperCase());//ABCDF
		System.out.println(str5.toLowerCase());//abcdf
		
		
		String str6 = "    index    xixi   ";
		System.out.println(str6);
		System.out.println(str6.trim());
	}
}

2.泛型【重点难点】

2.1为啥要使用泛型

广泛的类型，在开发中对数据一致性的要求是比较高的

例如：

数组中存数据 都是同一个类I型的

int[] arr = new int[]

char[] arr = new char[]

import java.util.ArrayList;
import java.util.Scanner;

public class Demo1 {
	public static void main(String[] args) {
		
		int[] arr = {1,2,3,4};
		//STring类不用导包 为啥？  因为 在 java.lang包下面
		String[] strs = {"nx", "hsjj", "xnjasjn"};
		
		//数组确实可以保证数据类型一致性，但是开发不用！！！为啥？  数组的方法比较少，而且数组容量提前定好的
		//不太方便 咋办？学习集合  明天讲
		 //集合的作用是和数组类似  都是容器  用来存数据的
		ArrayList list   = new ArrayList();//list  就是容器  就是用来存数据的
		list.add("狗蛋");//添加
		list.add(34);
		list.add('智');
		list.add(true);
		System.out.println(list);
		//以上代码好不好？不好！！！在开发中对数据一致性的要求是比较高的
		//获取一个数据
		String obj = (String)list.get(0);
		System.out.println(obj);
		//需要强转不好，现在有一个技术 泛型 可以保证咱们的数据一致性 针对于集合
		//ArrayList<类> 
		//<String> 告知编译器　　此集合只能存放String类型的数据  一致性保证一下
		ArrayList<String>  list1 = new ArrayList<String>();
		list1.add("张三");
		list1.add("王二");
		list1.add("wangliu");
		System.out.println(list1);
		String str1 = list1.get(0);
		System.out.println(str1);
		//泛型在<类>    如果放int类型的数据===》Integer
		ArrayList<Integer> list2 = new ArrayList<Integer>();
		list2.add(23);
		//扩展：  八大基本数据类型所对应的包装类
		/**
		 * byte ==> Byte
		 * short===>Short
		 * int===>Integer
		 * long===>Long
		 * boolean-===>Boolean
		 * char===>Character
		 * float===>Float
		 * double====>Double
		 */
	}
}

2.2自定义泛型在方法中的使用

语法格式：

public  <无意义的占位符> 返回值的类型 方法的名字 (参数) {

}

无意义的占位符:可以任意的字符 但是都大写的 开发中一般是 T (Type) E (Element) ?(未知)

入门案例：

public class Demo2 {
	public static void main(String[] args) {
		test(89);// test(T t)   T===>Integer 
		test("goudan");// test(T t)   T====>String
//	public static void test (int i) {
//		System.out.println(i);
//	}
//	public static void test (double i) {
//		System.out.println(i);
//	}
//	public static void test (String i) {
//		System.out.println(i);
//	}
	}
	//写泛型的入门级别的案例  更具有广泛性质
	//T随着方法的实参 而改变他的类型
	public static <T> void test(T t) {//T 代表所有的类型
		System.out.println(t);
	}
}

无参无返回值

有参无返回值

无参有返回值

有参有返回值

public class Demo3 {
	public static void main(String[] args) {
		test();
	}
	//无参无返回值的方法  没有必要使用泛型
	public static <T>  void test () {
		System.out.println("hewllo  world");
	}
	
	//有参无返回值的方法   可以使用
	public static <T> void test (T t, T t1) {
		//t  是多个类型  操作的时候要符合数据类型相对应的操作方式
		System.out.println(t + "" + t1);
	}
	
	//无参 有返回值的    没有必要使用泛型的
	public static <T> T test1 () {
		
		return null;
	}
	
	//有参 有返回值的方fa  写起来有局限性
	public  static <T>  T test2 (T t, T t1) {
		return t;
	}
	//有参的才有一点用途
	
}

2.3泛型类[重点]

语法格式：

class 类名 <无意义的占位符> {
	
}

class Person<T> {
	//泛型类中可以有普通的方法
	public void eat() {
		System.out.println("吃饭饭");
	}
	//带有泛型的方法   
	//public <T> void test() {一般在泛型类中的方法中不要去写<T>  因为方法的参数 根据类后面的<T> 来约束的
	public void test (T t) {
		System.out.println(t);
	}
	//静态方法  自娱自乐
	//当创建对象的时候才确定泛型类型，静态方法早于对象的创建，所以你的泛型对我是没有任何用的
	//告知程序员此处的泛型和类的泛型没有关系的
	public static <E> void test1 (E e) {
		System.out.println(e);
	}
}
public class Demo4 {
	public static void main(String[] args) {
		
		Person.test1(78);
		Person<String> strPerson = new Person<String>();
		//现在T是String  就意味者在调用test方法的时候 参数只能传String
		strPerson.test("goudan");
		//strPerson.test(89);
	}
}

2.4泛型抽象类

语法格式：

abstract class 类<无意义的占位符> {

}

abstract class A<T> {
	abstract void test(T t);
}
//1.在继承抽象类时候  子类也必须带有和父类相同的泛型占位符
class ATest<T> extends A<T> {
	void test(T t) {
	
	} 
}
public class Demo5 {
	public static void main(String[] args) {
		ATest<Integer> aTest = new ATest();
		aTest.test(67);
	}
}

2.5泛型接口

语法格式：

interface 接口名字<无意义的占位符> {

}

interface B<T> {
	 void test(T t);
}
class BTest<T> implements B<T> {
	   public void test(T t) {
		System.out.println("xixi ");
	}
}
public class Demo6 {
	public static void main(String[] args) {
		
	}
}

3.权限修饰符

权限修饰符	当前类	同一个包下的其他类	其他包下的子类	其他包的其他类
public	可以	可以	可以	可以
protected	可以	可以	可以	不可以
默认的	可以	可以	不可以	不可以
private	可以	不可以	不可以	不可以