JavaEE基础杂乱知识

随便笔记

2019.2.28

• 字母大小写强制转换：

​ 大写字母数值小，小写字母数值大，同一字母大小写差值32。

	char ch = 'J';
	ch = (char) (ch + 32);
	System.out.println(ch);
	char ch2 = 'a';
	ch2 -= 32;
	System.out.println(ch2);

• 如果要对一个表达式强制转换数据类型，需要将表达式括起来

	ch = (char) (ch + 32);

2019.3.1

​ 1、switch的交互式案例---------未听

2019.3.2

​

2019.3.3

休息！

2019.3.4

• 打印一个数组，是打印他的地址

• 打印调用一个数组的内容，才会调出数组的内容

​ 例：arrs = null 会使得数组的地址变为null，找不到堆内存中的地址。

​ for遍历和foreach遍历的各自优缺点：

​ for循环遍历知道自己遍历到了那离

​ foreach的优势是简单，缺点是不知道遍历到哪里。

​ 如何把数组arrs1变量的地址赋给数组arrs2变量？

	int [] arrs2 = arrs1;

2019.3.5

• 需求：判断一件事是否成立，

​ 解决方案：可以先新设一个变量，将变量的值设为true，然后再进行循环判断该条件是否成立：如果不成立（!=）则直接break，如果在循环判断中没有遇到break，则执行先前设定变量的默认值true。

• 一个方法中return后面的代码不会被执行，是指要在方法中的return被执行后，后面的代码才不会被执行；如果这个return没有被执行，（例如需要if判断的时候，return作为if判断的执行体代码，如果条件不成立，那么return就不会被执行。）那么后面的代码依然会运行。

public static boolean equals(int[] arr1, int [] arr2 ){
        int arr = 0;
        if(arr1.length != arr2.length){
            return false; //如果两个数组的长度相等，则这个return不会被执行
        }
        for(int i = 0; i <arr1.length; i++ ){
            if(arr1[i] != arr2[i] ){
                return false;  //如果两个数组的元素一一对应相等，则这个return不会被执行
            }
        }
        return true;
    }

2019.3.6

• 无参数构造器和有参数构造器的区别：

​ 无参数构造器默认不能为对象初始化数据，只能自己赋值。对象的数据都是默认值。
​ 有参数构造器可以初始化对象，并且在初始化对象的时候直接把对象的数据赋值好！！！

• 静态方法和实例方法的访问

​ 静态方法的访问：
​ 类名.静态方法。
​ 对象.静态方法。（不推荐）

​ 实例方法的访问：
​ 对象.实例方法。

• 成员变量、方法、构造器

​ 成员变量的定义格式：

	[修饰符] <数据类型>  <变量名称> [= 初始值];

​ 方法的格式：
​

	[修饰符] <返回值类型> <方法名称>(形参列表){
    	方法体;
 		}

​ 构造器的定义格式:

	[修饰符] 类名(形参列表){
    	执行代码;
		}

​ 构造器初始化对象的写法：
​

	类名 对象名称 = new 构造器;

2019.3.7

• 无参构造器和有参构造器的使用区别：

  	Student swk = new Student("孙悟空", 500 , "108期" );
  	System.out.println(swk.getName());
  	System.out.println(swk.getAge());
  	System.out.println(swk.getClassName());
  

  	Student swk = new Student();
  	swk.setName("孙悟空"); 
  	swk.setAge(500);  
  	swk.setSex("108期"); 
  	System.out.println(swk.getName()); 
  	System.out.println(swk.getAge()); 
  	System.out.println(swk.getSex());
  

• 继承后的特点_构造器。
  调用子类的构造器，子类构造器一定会先调用父类的无参数构造器。

• super(…)和this(…)的用法

  this：
  this.成员变量;访问当前对象成员变量。
  this.方法; 访问当前对象方法。
  this(…):在本类构造器中访问本类中其他构造器

  super
  super.成员变量;访问父类对象成员变量。
  super.方法; 访问父类对象方法。
  super(…):在本类构造器中访问父类构造器

  目标：研究super(…)调用父类构造器。
  (1)super()是默认就在子类构造器的第一行，一定会先去找父类的无参数构造器。
  (2)super(…)根据参数去寻找父类匹配的构造器。

  小结：
  super(…)可以把子类的数据送给父类的有参数构造器帮助初始化对象数据！

2019.3.8

• 父类定义的私有的成员变量，其他类只能setter、getter方法去调用（取值、赋值）。

2019.3.11

2019.3.12

• 在定义的测试类中需要写一个方法，但这个方法中需要传入的参数需要引用普通类中的相关参数，name我们可以在类中先写好方法，然后在测试类中新写一个方法用来调用普通类中的方法，以实现曲线救国。参数在类中直接传给方法，在测试类中写方法来调用这个方法，最后调用函数，以达到目标。

  //普通类中Person：
  	private String name;
      private int age;
  
  	public Person(String name, int age) {
          this.name = name; this.age = age;
      }
  
      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;}
  
  //普通类Student继承Person：
  	public void playBasketball() {
          System.out.println(this.getAge()+this.getName());
      }
  
  //测试类中：
  	static void goToSport(Sport sport){
          sport.playBasketball();
      }
  
  	public static void main(String[] args) {
          SportTeacher t2 = new SportTeacher("苍老师",35);
          goToSport(t2);
      }
  

2019.3.13

• 一段很6的代码

  已经定义了一个集合，这个集合的数据的数据类型为对象，如果要将集合内的数据（即对象）取出来一条，那么可以将这个数据（对象）取出来，然后赋值给一个Goods类型的变量goods，即可实现在方法内找回对象

  这样写的好处是：写方法时无需传参，即可在方法内实现调用对象

  public void total0(){
      double off = 0; //折扣价
      double sum = 0; //原价
      for (int i = 0; i < list.size(); i++){
          Goods goods = list.get(i);
          double price = goods.getPrice();
          sum += price;
  		//如果为电子产品，就打折计算
          if (goods instanceof EGoods){
              price *= 0.88;
          }
          off += price;
      }
      System.out.println(sum+"\n"+off);
  }
  

2019.3.16

• 如何使用Random的next方法录入一个字符串

    Scanner sca = new Scanner(System.in);
    System.out.println("请输入字符串：");
    String str = sca.next();
  

2019.3.17

• 内部类的访问

  • 实例内部类可以直接访问外部类的哪些成员？
    实例内部类中可以直接访问外部类的所有成员，因为实例内部类属于外部类对象。
  • 研究静态内部类能否访问外部类的成员：
    静态内部类，可以直接访问外部类的静态成员。
    静态内部类，不可以直接访问外部类的实例成员，因为外部类的实例成员只能用外部类的对象访问！！

• 关于equals

  • equals用作字符串的比较

  • equals比较两个值是拿内存地址来作为比较对象的，每一次new都会在内存中开辟一片新的内存地址来存储变量，所以尽管有两个值相同的变量来比较，但是他们的内存地址不同的话，equals比较的返回值依然会是false。

  • 但是可以通过重写equals方法来达到比较两个字符串的值？喵喵喵

• instanceof

• 关于多态

• toString一般要重写（因为需要打印字符串的内容，而不是内存地址值），equals根据需要选择是否重写（是要比较内容还是内存地址值）

• 查找API文档：明确是否需要传参与返回值后根据条件查找

2019.3.18

• 增强for循环

  增强for循环，也可以用来循环集合，当然循环String类型的数组和集合也是没有问题的，只需要改数据类型

	int[] arr = {11, 22, 33};	
    for (int num:arr) {
        System.out.println(num);
    }

    ArrayList<String> list = new ArrayList<>();
	list.add("a");
	for (String str:list) {
            System.out.println(aaa);
    }

• JDK1.7之前定义集合ArrayList的写法

  //JDK1.7之前：
  ArrayList <String> list = new ArrayList<String>();
  //现在的写法：
  ArrayList <String> list = new ArrayList<>();
  

• 数组和集合的遍历

  • 数组的遍历有两种方法：for循环和增强for循环；

  • 集合（ArraryList）的遍历在遍历数组方法的基础上多了一种方法，即迭代器。所以集合ArrartList的遍历有三种方法：for、增强for、迭代器（Collection + Iterator + while）。

  • 迭代器（Collection + Iterator + while）的用法

        ArrayList<String> list = new ArrayList();
        list.add("aa");
        list.add("bb");
        list.add("cc");
    
        // 使用迭代器遍历集合
        Iterator<String> it = list.iterator();
        
    	while (it.hasNext()){
          /*  // 获得元素并输出字符串的长度(如果迭代器未标注<>，则需要强转，如下）
            String str = (String) it.next();
            System.out.println(str.length());*/
    
            String str = it.next();
            System.out.println(str.length());
        }
    

2019.3.19

• Collection

  //多态的用法，Collection是所有单列集合的父接口
  Collection<Student> list = new ArrayList<>();
  

• Collection是所有单列集合的父接口，ArrayList是一个实现类，他实现了Collection接口。