2018-12-04笔记

 

 

 

抽象类和接口不可以有构造方法……

 

匿名内部类：开发中很常用……

 

抽象类中的非抽象方法不需要重写（并非强制重写）……

 

示例：

package com.oracle.demo01;

public abstract class Test {

         public static void main(String[] args) {

                   //匿名内部类对象：

                   //格式：new 接口或者抽象类{重写父类的抽象方法}.调用方法或者属性

                  

                   //方式1：

                   new Smoking(){

                            public void smoke(){

                                     System.out.println("抽烟");

                            }

                   }.smoke();

                  

                   //方式2：

                   Smoking s=new Smoking(){

                            public void smoke(){

                                     System.out.println("抽烟");

                            }

                   };

                   s.smoke();

         }

}

 

最常用到的内部类就是匿名内部类，它是局部内部类的一种：

定义的匿名内部类有两个含义：

①   临时定义某一指定类型的子类；

②   定义后即刻创建刚刚定义的这个子类的对象；

 

匿名内部类是创建某个类型子类对象的快捷方式；

 

定义格式：

new 父类或接口(){

         //进行方法重写

};

 

匿名内部类如果不定义变量引用，则也是匿名对象；代码如下：

new Person(){

         public void eat() {

                   System.out.println(“我吃了”);

}

}.eat();

 

Java的包，其实就是我们电脑系统中的文件夹，包里存放的是类文件；

 

类中声明的包必须与实际class文件所在的文件夹情况相一致，即类声明在a包下，则生成的.class文件必须在a文件夹下，否则，程序运行时会找不到类；

 

src存放源码.java文件，bin目录存放.class文件……

 

包名是公司网址反写……

 

类中包的声明格式：

package 包名.包名.包名…;

 

注意：声明包的语句，必须写在程序有效代码的第一行（注释不算）!

 

在访问类时，为了能够找到该类，必须使用含有包名的类全名（包名.类名）!

 

如果不导包，创建对象：

包名.类名 变量名 = new包名.类名();

 

导包：

import java.util.*;

//*是通配符！

 

在package和public class之间导包……

 

	public	protected	default	private
同一类中	√	√	√	√
同一包中(子类与无关类)	√	√	√
不同包的子类	√	√
不同包中的无关类	√

修饰符！

 

要想仅能在本类中访问使用private修饰；

要想本包中的类都可以访问不加修饰符即可；

要想本包中的类与其他包中的子类可以访问使用protected修饰；

要想所有包中的所有类都可以访问使用public修饰；

注意：如果类用public修饰，则类名必须与文件名相同；一个文件中只能有一个public修饰的类；

 

 

代码块：

局部代码块是定义在方法或语句中

特点：

以”{}”划定的代码区域，此时只需要关注作用域的不同即可

方法和类都是以代码块的方式划定边界的

 

package com.oracle.demo02;

public class Test {

         public static void main(String[] args) {

                   //局部代码块：没什么特点，执行到就去走一下……

                   {

                            int x=1;

                            System.out.println(x);

                   }

         }

}

 

构造代码块：

构造代码块是定义在类中成员位置的代码块

特点：

优先于构造方法执行，构造代码块用于执行所有对象均需要的初始化动作

每创建一个对象均会执行一次构造代码块，且只执行一次！

 

package com.oracle.demo02;

public class Test {

         public static void main(String[] args) {

                   GouZaoDMK gz=new GouZaoDMK();

         }

}

 

package com.oracle.demo02;

public class GouZaoDMK {

         public GouZaoDMK(){

                   super();

                   System.out.println("构造方法");

         }

        

         {

                   System.out.println("构造代码块");

         }

}

 

静态代码块：

静态代码块是定义在成员位置，使用static修饰的代码块。

特点：

它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。

该类不管创建多少对象，静态代码块只执行一次；

可用于给静态变量赋值，用来给类进行初始化；

 

package com.oracle.demo02;

public class Test {

         public static void main(String[] args) {

                   GouZaoDMK gz1=new GouZaoDMK();

                   GouZaoDMK gz2=new GouZaoDMK();

         }

}

 

package com.oracle.demo02;

public class GouZaoDMK {

         public GouZaoDMK(){

                   super();

                   System.out.println("构造方法");

         }

        

         {

                   System.out.println("构造代码块");

         }

        

         static{

                   System.out.println("静态代码块");

         }

}

 

//静态代码块：用于做初始化用的……

 

 

Java中常用的API：

 

Java 的API（API: Application(应用) Programming(程序) Interface(接口)），即Java标准类库……

 

百度一下底层原理……

 

ArrayList底层就是数组！

 

在JDK安装目录下有个src.zip文件，这个文件解压缩后里面的内容是所有Java类的源文件；可以在其中查看相对应的类的源码！

 

更简单的方式是使用Java API

 

Object类：

Object类是Java语言中的根类，即所有类的父类；它中描述的所有方法子类都可以使用；所有类在创建对象的时候，最终找的父类就是Object！

equals方法，用于比较两个对象是否相同，它其实就是使用两个对象的内存地址在比较！

 

Object中的equals()方法：

 

所以两种引用数据类型在需要比较内容时，需要重写euqals方法：

String类天生重写了从Object那里继承来的equals()和toString方法！

 

案例：

package com.oracle.demo03;

public class Person {

         private String name;

         private int age;

         public Person(){

                  

         }

         public Person(String name, int age) {

                   super();

                   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;

         }

         //重写euqals方法：

         public boolean equals(Object obj) {

                   if (this == obj)

                            return true;

                   if (obj == null)

                            return false;

                   if (getClass() != obj.getClass())

                            return false;

                   Person other = (Person) obj;

                   if (age != other.age)

                            return false;

                   if (name == null) {

                            if (other.name != null)

                                     return false;

                   } else if (!name.equals(other.name))

                            return false;

                   return true;

         }

         //重写toString方法

         public String toString() {

                   return "Person [name=" + name + ", age=" + age + "]";

         }

}

 

package com.oracle.demo03;

public class Test2 {

         public static void main(String[] args) {

                   Person p1=new Person("小红帽",18);

                   //引用数据类型会默认调用toString方法，p1和p1.toString是等价的！

                   System.out.println(p1);

                   System.out.println(p1.toString());

         }

}

 

String类：

字符串是一个常量，赋值之后不可更改；

本质是一个字符数组char[]；

 

在堆中有一块区域，专门用于存放常量的；

运行时常量池：在常量池中有一个char[]数组，看字符串内容分配内容……然后将地址交给引用……没办法修改char数组的值，只能换引用指向的地址！

 

只要程序没结束，即使断了指向，也会一直存在，知道程序main方法结束；

 

首先要进堆的，final修饰的才进常量池……

 

常量池中一旦有一个char数组组合存在了，就不会再创建新的char数组组合了！

 

String str1="ABC";

String str2=new String("ABC");

System.out.println(str1==str2);

System.out.println(str1.equals(str2));

//因为str2使用new创建对象了，所以==时对比地址

 

String s3 = "abc";

String s4 = new String("abc");

System.out.println(s3==s4);//false

System.out.println(s3.equals(s4));//true,

//因为String重写了equals方法，建立了字符串自己的判断相同的依据（通过字符串对象中的字符来判断）

 

s3和s4的创建方式有什么不同呢？

s3创建，在内存中只有一个对象。这个对象在字符串常量池中

s4创建，在内存中有两个对象。一个new的对象在堆中，一个字符串本身对象，在字符串常量池中

 

String s4 = new String("abc");

//abc在常量池中，new String在常量池外面的堆中，只持有一块地址，然后交给str2的引用

 

String构造方法摘要：

Byte-->char-->传入数字走ASCII码表

 

package com.oracle.demo04;

public class Demo02 {

         public static void main(String[] args) {

                   method04();

         }

         public static void method01(){

                   byte[] bytes={-97,-98,-99,-100};

                   //byte数组中的内容会被转成char[]数组，对照ASCII码表

                   //48-57:0--9

                   //65-91：A--Z

                   //97-123：a--z

                   //ASCII负数表示汉字，一个汉字两个字节，四个数字，是两个汉字；如果3个字节会出现一个汉字一个?号乱码

                   //字节数组转字符串，正数走ASCII码表，负数转汉字；

                   String str=new String(bytes);

                   System.out.println(str);

         }

        

         public static void method02(){

                   byte[] bytes={65,66,67,68};

                   String str=new String(bytes,1,2);//从byte数组第几个下标开始，转几个；

                   System.out.println(str);

         }

        

         public static void method03(){

                   char[] ch={'中','a','2','t'};

                   String str=new String(ch);

                   System.out.println(str);

         }

        

         public static void method04(){

                   char[] ch={77,67,100,101};

                   String str=new String(ch,0,1);

                   System.out.println(str);

         }

}

获取字符串长度，即char[]的长度！

截取字符串方法！

package com.oracle.demo04;

public class Demo03 {

         public static void main(String[] args) {

                   method03();

         }

         public static void method01(){

                   String str="abcd";

                   System.out.println(str.length());

         }

        

         public static void method02(){

                   String str="chinanihao";

                   String s=str.substring(5);//从下标5开始一直截取到最后

                   System.out.println(s);

         }

        

         public static void method03(){

                   String str="chinanihao";

                   String s=str.substring(5,6);//输出n，包头不包尾

                   System.out.println(s);

         }

}

public static void method04(){

                   String str="javanihao";

                   boolean flag=str.startsWith("java");

                   System.out.println(flag);

         }

        

         public static void method05(){

                   String str="Person.java";

                   boolean flag=str.endsWith(".java");

                   System.out.println(flag);

         }

public static void method06(){

                   //判断一个字符串中是否包含另一个字符串

                   String str="javanihaojava";

                   boolean flag=str.contains("java");

                   System.out.println(flag);

         }

        

         public static void method07(){

                   //获取一个字符串在另一个字符串中第一次出现的索引

                   String str="javanihao";

                   int index=str.indexOf("java");//如果str字符串中传入一个不存在的字符串，返回-1

                   System.out.println(index);

         }

Char可以定义byte字节（byte自动解析成char字符）也可以定义单个字符；

 

字节转成字符或者转成字符串时都会走ASCII码表；

 

         public static void method08(){

                   //字符串转字节数组

                   String str="china";

                   byte[] bytes=str.getBytes();

                   char[] ch=str.toCharArray();

                   for(int i=0;i<bytes.length;++i){

                            System.out.print(bytes[i]+"\t");

                   }

                   System.out.println();

                   for(int i=0;i<ch.length;++i){

                            System.out.print(ch[i]+"\t");

                   }

         }

String str="javagood";

System.out.println(str.equals("javaGOOD"));

System.out.println(str.equalsIgnoreCase("JavaGood"));

 

作业：

下面的需求所对应的方法，要求大家自己动手在API中查找，并进行方法使用。

判断该字符串的内容是否为空的字符串     isEmpty()

获取给定的字符，在该字符串中第一次出现的位置         indexOf()

获取该字符串中指定位置上的字符     charAt()

把该字符串转换成 小写字符串  tolowercase

把该字符串转换成 大写字符串  toUppercase()

在该字符串中，将给定的旧字符，用新字符替换     replace(char oldchar,char newchar)

在该字符串中， 将给定的旧字符串，用新字符串替换  replaceAll()

去除字符串两端空格，中间的不会去除，返回一个新字符串         trim()