1 数组
//静态初始化
int[] arr1=new int[]{1,2,3,4}
//简化形式
int[] arr2={1,2,3,4}
//动态初始化
int[] arr3=new int[5]2 方法重载
在同一个类中的多个方法的方法名相同,参数个数不同，参数类型不同，参数类型顺序不同
public class Test1 {public static void main(String[] args) {Animal animal = new Animal();animal.m(1);animal.m(1.1);animal.m(1,1.1);animal.m(1.1,1);}
}
class Animal{public void m(int n){System.out.println("int");}public void m(double n){System.out.println("float");}public void m(int n,double m){System.out.println("int n,float m");}public void m(double m,int n){System.out.println("float m,int n");}
}
3 数据类型
3.1 基本数据类型
//数据值存储在自己空间中
int a=1;3.2 引用数据类型
//数据值存储在其他空间中,指向堆内存
int[] arr=new int[]{1,2,3};
//传递的地址值
int[] arr1=arr;
4 IDEA
编写代码：project->module->packege->class，自动保存和编译
快捷键：
sout：
System.out.println();
psvm：
public static void main(String[] args) {}
5 封装
私有变量+get、set方法
public class Object {
//成员变量private String name;private int age;public void setAge(int n){
//局部变量int b=1;if(n>=18&&n<=50){age = n;}else{System.out.println("非法参数");}}public int getAge(){return age;}
}public void setAge(int age){if(n>=18&&n<=50){//自己传递给自己age = age;//把值传递给成员变量的age//age就近原则，this是调用者的地址值，所以this===对象类new声明的变量this.age=age;}else{System.out.println("非法参数");}}构造方法
public class Object {// 方法名与类名相同，没有返回值，由虚拟机在创建对象的时候自动调用public Object() {}
}6 标准javaBean
成员变量private，且提供set、get
至少两个构造方法：1 无参构造 2有全部参数构造
alt+insert：要有空参构造和全参构造
插件快速构造
7 字符串
7.1string
是java定义好的类，定义在java.lang包，使用不需要导包
public Object() {}
//当使用双引号直接赋值，会查该字符串在串池是否存在//存在：复用，指向相同地址//不存在：创建新的String s1="abc";String s2=new String();String s3=new String("123456");char[] c={'1','2','3'};//s4与s6指向地址不同String s4=new String(c);String s6=new String(c);
// 字节数组转为字符串byte[] b={12,13,14};String s5=new String(b);
//表示内容相等么？boolean b1=s5.equals(s4);boolean b2=s5.equalsIgnoreCase(s4);
}7.2 StringBuilder
public static void main(String[] args) {// 创建一个可变字符串对象StringBuilder sb=new StringBuilder("abc");sb.append("de");System.out.println(sb);//abcdesb.reverse();System.out.println(sb);//edcba
// 容量sb.capacity();
// 容量内字符串长度sb.length();}源码分析：默认创建一个长度16的字节数组，大于16会扩容
7.3 StringBuffer
String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址,String是被final修饰的类，不能被继承
StringBuffer保存的是字符串变量，里面的值可以修改
String s1=new String("");StringBuffer sb=new StringBuffer();System.out.println(s1);//空
// 打印的是属性值System.out.println(sb);//1
// 每次加一个值sb.append(1);sb.reverse();System.out.println(sb);
// 把StringBuffer变为字符串String str=sb.toString();7.4 StringJoiner
StringJoiner sj=new StringJoiner("---");sj.add("111").add("222");System.out.println(sj);//111---222StringJoiner sj1=new StringJoiner("---","[","]");sj1.add("111").add("222");System.out.println(sj1);//[111---222]拼接：
JDK8之前StringBuilder的append()方法
JDK8之后预估string拼接后大小，然后把内容放入数组，产生一个新字符串
==比较的是？
引用数据类型比较地址值
基本数据类型比较数据值
7.5 转换罗马数字案例
package DEMO1;import java.util.Scanner;public class Object {public static void main(String[] args) {String s;Scanner sc=new Scanner(System.in);while (true){s=sc.next();if(check(s)){break;}else {System.out.println("error");continue;}}StringBuilder sb=new StringBuilder();for(int i=0;i<s.length();i++){char c=s.charAt(i);sb.append(change(c-48));}System.out.println(sb);}public static String change(int number){String arr[] = {"","Ⅰ","Ⅱ","Ⅲ","Ⅳ","Ⅴ","Ⅵ","Ⅶ","Ⅷ","Ⅸ"};return arr[number];}public static boolean check(String s){if(s.length()>9){return false;}for(int i=0;i<s.length();i++){char c=s.charAt(i);if(!(c>'0'&&c<'9'))return false;}return true;}
}7.6 泛型
public class Test1 {public static void main(String[] args) {
// 泛型：限定集合中存储的数据类型
// 打印的是内部数据内容
// 不能放基本数据类型，string是引用数据类型ArrayList<String> list=new ArrayList<>();list.add("aaa");list.add("bbb");list.add("ccc");list.add("ddd");list.remove("ccc");System.out.println(list);
// 删除1索引的数值是第二个值list.remove(1);System.out.println(list);
// 修改list.set(1,"eee");System.out.println(list);
// 遍历for(int i=0;i<list.size();i++){String str=list.get(i);System.out.println(str);}}
}8 static变量
修饰成员方法、成员变量
被所有类所共享，不属于特定对象
推荐用类名调用，也可以用对象名调用
静态变量是随着类加载而加载，优先于对象出现
堆内存
工具类：不描述具体事物，而是做事情的类
私有化构造方法，不让外界创建其对象
方法定义为静态，静态方法没有this关键字
9 继承
java只支持单继承，不支持多继承，但支持多重继承
所有类都继承object类
子类不可以继承父类所有构造方法，能继承父类所有成员变量，能继承非私有的成员方法
父类、子类都有自己的虚方法表，包括非private、非static、非final
只有父类虚方法才能被子类继承和重写
public class student {String name;int age;
// 表示当前调用者的地址值
// this是由虚拟机赋值的,而不能手动赋值public void show1(student this){System.out.println(this);
// 相当于this.nameSystem.out.println(name);};
}studentTest
public class studentTest {public static void main(String[] args) {student s1=new student();System.out.println(s1);s1.show1();}}
调用子类父类的方法或声明
Test1.java
public class Test1 {String b="3";
}Test2.java
public class Test2 extends Test1{public static void main(String[] args) {Test2 t2=new Test2();t2.func();}String c="2";public void func() {System.out.println(c);//2System.out.println(b);//3System.out.println(super.b);//3System.out.println(this.b);//3}
}成员变量访问特点：就近原则
10 重写
重写的方法名称、形参必须与父类一致，权限>父类（public>protected>不写），返回值类型<=父类
方法的重载是方法的参数个数或种类或顺序不同，方法名相同
快捷键：
11 多态
前提；1 有继承 2 有重写 3 父类引用指向子类对象
多态成员变量：编译运行看左边
方法：编译看左边，运行看右边
Animal.java
public class Animal {public int age=20;public static void sleep(){System.out.println("动物在睡觉");}public void func() {System.out.println("我是animal");}
}Dog.java
package DEMO1;public class Dog extends Animal{public int age=18;public static void sleep(){System.out.println("dog在睡觉");}@Overridepublic void func() {super.func();System.out.println("我是dog");}public void eat(){System.out.println("dog吃饭");}}
Test1.java
package DEMO1;public class Test1 {public static void main(String[] args) {Animal animal = new Animal();animal.func();Dog dog=new Dog();dog.func();Animal Adog=new Dog();
// 子父类存在同名的非静态成员方法时，访问的是子类中重写的方法Adog.func();//我是dog
// 多态情况下，子父类存在同名的静态成员变量成员方法时，访问的是父类的成员函数Adog.sleep();//动物在睡觉
// 多态情况下，子类和父类存在同名的成员变量时，访问的时父类的成员变量System.out.println(Adog.age);//20
// 多态情况下，不能访问子类独由的方法
// Adog.eat();
// 向下转型Dog dog1=(Dog)dog;dog1.func();//我是dog}
}报错问题：将子类Cat的对象cat变成了兄弟类的对象dog,这就不是向下转型，因此会报ClassCastException类型转换异常
Animal cat = new Cat();//向下转型Dog dog1 = (Dog)Adog;//调用子类独有的方法dog1.func();
instanceof关键字
Animal Adog=new Dog();if(Adog instanceof cat){cat ca=(cat)Adog;ca.func();//我是animal}else if(Adog instanceof Dog){Dog dog2=(Dog) Adog;dog2.func();//我是dog}12 包和final
12.1 包
包是文件夹，管理不同java类
名称：公司域名反写+包的作用
使用java.lang包的类，不需要导包
12.2 final
不能重写、继承，常量
final 基本类型：数据不能改变
final 引用类型：（数组）地址值不能改变，内部数据可以改变
常量：全部大写，多个单词用'_'隔开
13 权限修饰符
14 代码块
14.1 局部代码块
public static void main(String[] args) {{int a=1;System.out.println(a);}
// 代码块执行完，a占用的内存就清除，现在基本用不到}14.2 构造代码块
public class Test1 {
// 多个构造方法重复的代码写在构造方法块
// 构造方法块优于构造方法执行{System.out.println("我是老大");}public Test1(){System.out.println("我是老二");}public Test1(int a){System.out.println("我是老三");}public static void main(String[] args) {Test1 te=new Test1();Test1 te1=new Test1(2);}
}节省重复代码第二种方式：
public class Test1 {public Test1(){System.out.println("我是老二");}public Test1(int a){this();System.out.println("我是老三");}public static void main(String[] args) {Test1 te=new Test1(2);}
}
14.3 静态代码块
创建子类对象实例，父类也会被加载，父类先被加载，子类后被加载
public class Test1 {public static void main(String[] args) {System.out.println(B.n1);}
}
class A{public static int n2=20000;static{System.out.println("1");}
}
class B extends A{public static int n1=10000;static {System.out.println(n2);}
}
普通代码块:每次创建一个对象就执行一次
静态代码块:只要类加载了就会被调用,只会执行一次
public class Test1 {public static void main(String[] args) {System.out.println(A.n2);A a=new A();}
}
class A{public static int n2=20000;static{System.out.println("静态代码块被调用");}{System.out.println("普通代码块被调用");}
}
类什么时候被加载:
1 new:A a = new A();
2 使用类的静态成员:静态成员，静态方法
15 抽象类
Animal.java
package DEMO1;
//抽象类不能被实例化
public abstract class Animal {private int age;//初始化父类成员使用public Animal(){this.age=age;}public void sleep(){System.out.println("动物在睡觉");}//只有方法的定义，没有方法的实现//有抽象方法，那么这个类必定是一个抽象类//抽象类里面可以没有抽象方法public abstract void eat();
}Dog.java
public class Dog extends Animal{//所有非抽象子类必须重写抽象类中的抽象方法@Overridepublic void eat() {System.out.println("我是dog");}
}Main.java
public class Main {public static void main(String[] args) {Dog do1=new Dog();do1.eat();do1.sleep();}
}
16 接口
Temnal->jps-> jhsdb hsdb 打开内存分析工具->file->
Swim.java
public interface Swim {//默认加上public static finalint a=10;//默认加上public abstractvoid method();public abstract void swim();
}Frog.java
//要么重写所有抽象方法要么抽象类
public class Frog extends Animal implements Swim{
// 不加构造无法赋值public Frog(int age) {super(age);}public Frog(int age, String name) {super(age, name);}public Frog() {}public Frog(String name) {super(name);}@Overridepublic void eat() {System.out.println("青蛙吃");}@Overridepublic void method() {System.out.println("method");}@Overridepublic void swim() {System.out.println("青蛙游泳");}
}Main.java
public class Main {public static void main(String[] args) {Frog fr=new Frog(18,"青蛙");System.out.println(fr.getAge()+fr.getName());fr.eat();fr.swim();}
}
实现多个接口的同名方法，重写一次即重写了各个接口的方法
接口与接口，可以单继承，也可以多继承
Swim.java
package DEMO1;public interface Swim {
// public 可以省略，default不能省略//接口在进行扩展的时候，不会破坏与接口相关的实现类代码public default void method1(){System.out.println("method1没有重写Swim");};public default void method2(){System.out.println("method2有重写");};public static void jing(){System.out.println("我是静态");add();};private static void add(){System.out.println("静态的私有方法，节省代码");}}
Frog.java
package DEMO1;
//要么重写所有抽象方法要么是抽象类
public class Frog implements Swim{@Overridepublic void method1() {System.out.println("haha");}@Overridepublic void method2() {System.out.println("method2重写");}
}
Main.java
package DEMO1;public class Main {public static void main(String[] args) {Frog fr=new Frog();
// 实现的接口中存在相同名字默认方法，必须重写fr.method1();fr.method2();Swim.jing();}
}
适配器设计模式
swim.java
package DEMO1;public interface Swim {
public abstract void swim1();
public abstract void swim2();public abstract void swim3();public abstract void swim4();public abstract void swim5();public abstract void swim6();public abstract void swim7();public abstract void swim8();
}Rubbit.java
package DEMO1;public class Rubbit implements Swim{@Overridepublic void swim1() {}@Overridepublic void swim2() {}@Overridepublic void swim3() {}@Overridepublic void swim4() {}@Overridepublic void swim5() {}@Overridepublic void swim6() {}@Overridepublic void swim7() {}@Overridepublic void swim8() {}
}
Frog.java
public class Frog extends Rubbit {@Overridepublic void swim5() {System.out.println("我只用swim接口的5");}
}Main.java
public class Main {public static void main(String[] args) {Frog fr=new Frog();fr.swim5();}
}
17 内部类
17.1 成员内部类
JDK16之前不能定义静态变量，JDK16之后才可以定义静态变量
Animal.java
public class Animal {class eye{ }private class hand{}public hand gethand(){return new hand();}
}Main.java
public class Main {public static void main(String[] args) {Animal.eye ae=new Animal().new eye();
// hand不能用上面的方法newAnimal animal=new Animal();System.out.println(animal.gethand());//DEMO1.Animal$hand@682a0b20}
}
outer this是隐含的
17.2 静态内部类
Animal.java
package DEMO1;public class Animal {public int a=1;public static int b=2;static class eye{public static void show(){Animal an=new Animal();System.out.println(an.a);System.out.println(b);}public void show1(){System.out.println("3");}}
}
Main.java
package DEMO1;public class Main {public static void main(String[] args) {Animal.eye.show();
// Animal.eye.show1();show1不是静态方法，错误Animal.eye ae=new Animal.eye();ae.show1();}
}
17.3 局部内部类
类中函数里定义的类
17.4 匿名内部类
匿名内部类不能是抽象的，只能也必须继承一个类或者实现一个接口， 无构造，无静态
public class Main {public static void main(String[] args) {
// swim是接口，{}是匿名类,实现了Swim()这个接口，new的是匿名类
// Swim是抽象类，那么{}是其子类，new表示创建没有名字的对象new Swim(){@Overridepublic void swim(){System.out.println("1");};}.swim();//1Swim sw=new Swim() {@Overridepublic void swim() {System.out.println("2");}};sw.swim();//2System.out.println(sw.getClass());//获取类名class DEMO1.Main$2,这个类是被临时创建}
}应用：
package DEMO1;public class Main {public static void main(String[] args) {fun(new A(){@Overridepublic void eat() {System.out.println("eat");}});//eat}public static void fun(A s){s.eat();}interface A{public void eat();}
}
