抽象类和接口不可以有构造方法……
匿名内部类：开发中很常用……
抽象类中的非抽象方法不需要重写（并非强制重写）……
示例：
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]+" ");
}
System.out.println();
for(int i=0;i<ch.length;++i){
System.out.print(ch[i]+" ");
}
}
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()