1 数组
//静态初始化
int[] arr1=new int[]{1,2,3,4}
//简化形式
int[] arr2={1,2,3,4}
//动态初始化
int[] arr3=new int[5]
2 方法重载
在同一个类中的多个方法的方法名相同,参数个数不同，参数类型不同，参数类型顺序不同
java
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 引用数据类型
java
//数据值存储在其他空间中,指向堆内存
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方法
java
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;
}
}
java
public void setAge(int age){
if(n>=18&&n<=50){
//自己传递给自己
age = age;
//把值传递给成员变量的age
//age就近原则，this是调用者的地址值，所以this===对象类new声明的变量
this.age=age;
}else{
System.out.println("非法参数");
}
}构造方法
java
public class Object {
// 方法名与类名相同，没有返回值，由虚拟机在创建对象的时候自动调用
public Object() {
}
}6 标准javaBean
成员变量private，且提供set、get
至少两个构造方法：1 无参构造 2有全部参数构造
alt+insert：要有空参构造和全参构造
插件快速构造
7 字符串
7.1string
是java定义好的类，定义在java.lang包，使用不需要导包
java
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
java
public static void main(String[] args) {
// 创建一个可变字符串对象
StringBuilder sb=new StringBuilder("abc");
sb.append("de");
System.out.println(sb);//abcde
sb.reverse();
System.out.println(sb);//edcba
// 容量
sb.capacity();
// 容量内字符串长度
sb.length();
}源码分析：默认创建一个长度16的字节数组，大于16会扩容
7.3 StringBuffer
String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址,String是被final修饰的类，不能被继承
StringBuffer保存的是字符串变量，里面的值可以修改
java
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
java
StringJoiner sj=new StringJoiner("---");
sj.add("111").add("222");
System.out.println(sj);//111---222
StringJoiner sj1=new StringJoiner("---","[","]");
sj1.add("111").add("222");
System.out.println(sj1);//[111---222]拼接：
JDK8之前StringBuilder的append()方法
JDK8之后预估string拼接后大小，然后把内容放入数组，产生一个新字符串
==比较的是？
引用数据类型比较地址值
基本数据类型比较数据值
7.5 转换罗马数字案例
java
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 泛型
java
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
只有父类虚方法才能被子类继承和重写
java
public class student {
String name;
int age;
// 表示当前调用者的地址值
// this是由虚拟机赋值的,而不能手动赋值
public void show1(student this){
System.out.println(this);
// 相当于this.name
System.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
java
public class Test1 {
String b="3";
}Test2.java
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);//2
System.out.println(b);//3
System.out.println(super.b);//3
System.out.println(this.b);//3
}
}成员变量访问特点：就近原则
10 重写
重写的方法名称、形参必须与父类一致，权限>父类（public>protected>不写），返回值类型<=父类
方法的重载是方法的参数个数或种类或顺序不同，方法名相同
快捷键：
11 多态
前提；1 有继承 2 有重写 3 父类引用指向子类对象
多态成员变量：编译运行看左边
方法：编译看左边，运行看右边
Animal.java
java
public class Animal {
public int age=20;
public static void sleep(){
System.out.println("动物在睡觉");
}
public void func() {
System.out.println("我是animal");
}
}Dog.java
java
package DEMO1;
public class Dog extends Animal{
public int age=18;
public static void sleep(){
System.out.println("dog在睡觉");
}
@Override
public void func() {
super.func();
System.out.println("我是dog");
}
public void eat(){
System.out.println("dog吃饭");
}
}Test1.java
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类型转换异常
java
Animal cat = new Cat();
//向下转型
Dog dog1 = (Dog)Adog;
//调用子类独有的方法
dog1.func(); instanceof关键字
java
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 局部代码块
java
public static void main(String[] args) {
{
int a=1;
System.out.println(a);
}
// 代码块执行完，a占用的内存就清除，现在基本用不到
}14.2 构造代码块
java
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);
}
}节省重复代码第二种方式：
java
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 静态代码块
创建子类对象实例，父类也会被加载，父类先被加载，子类后被加载
java
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);
}
}
普通代码块:每次创建一个对象就执行一次
静态代码块:只要类加载了就会被调用,只会执行一次
java
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
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
java
public class Dog extends Animal{
//所有非抽象子类必须重写抽象类中的抽象方法
@Override
public void eat() {
System.out.println("我是dog");
}
}Main.java
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
java
public interface Swim {
//默认加上public static final
int a=10;
//默认加上public abstract
void method();
public abstract void swim();
}Frog.java
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);
}
@Override
public void eat() {
System.out.println("青蛙吃");
}
@Override
public void method() {
System.out.println("method");
}
@Override
public void swim() {
System.out.println("青蛙游泳");
}
}Main.java
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
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
java
package DEMO1;
//要么重写所有抽象方法要么是抽象类
public class Frog implements Swim{
@Override
public void method1() {
System.out.println("haha");
}
@Override
public void method2() {
System.out.println("method2重写");
}
}Main.java
java
package DEMO1;
public class Main {
public static void main(String[] args) {
Frog fr=new Frog();
// 实现的接口中存在相同名字默认方法，必须重写
fr.method1();
fr.method2();
Swim.jing();
}
}
适配器设计模式
swim.java
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
java
package DEMO1;
public class Rubbit implements Swim{
@Override
public void swim1() {
}
@Override
public void swim2() {
}
@Override
public void swim3() {
}
@Override
public void swim4() {
}
@Override
public void swim5() {
}
@Override
public void swim6() {
}
@Override
public void swim7() {
}
@Override
public void swim8() {
}
}Frog.java
java
public class Frog extends Rubbit {
@Override
public void swim5() {
System.out.println("我只用swim接口的5");
}
}Main.java
java
public class Main {
public static void main(String[] args) {
Frog fr=new Frog();
fr.swim5();
}
}
17 内部类
17.1 成员内部类
JDK16之前不能定义静态变量，JDK16之后才可以定义静态变量
Animal.java
java
public class Animal {
class eye{ }
private class hand{}
public hand gethand(){
return new hand();
}
}Main.java
java
public class Main {
public static void main(String[] args) {
Animal.eye ae=new Animal().new eye();
// hand不能用上面的方法new
Animal animal=new Animal();
System.out.println(animal.gethand());//DEMO1.Animal$hand@682a0b20
}
}
outer this是隐含的
17.2 静态内部类
Animal.java
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
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 匿名内部类
匿名内部类不能是抽象的，只能也必须继承一个类或者实现一个接口， 无构造，无静态
java
public class Main {
public static void main(String[] args) {
// swim是接口，{}是匿名类,实现了Swim()这个接口，new的是匿名类
// Swim是抽象类，那么{}是其子类，new表示创建没有名字的对象
new Swim(){
@Override
public void swim(){
System.out.println("1");
};
}.swim();//1
Swim sw=new Swim() {
@Override
public void swim() {
System.out.println("2");
}
};
sw.swim();//2
System.out.println(sw.getClass());//获取类名class DEMO1.Main$2,这个类是被临时创建
}
}应用：
java
package DEMO1;
public class Main {
public static void main(String[] args) {
fun(
new A(){
@Override
public void eat() {
System.out.println("eat");
}
}
);//eat
}
public static void fun(A s){
s.eat();
}
interface A{
public void eat();
}
}