持续更新中~
Java跨平台原因（重要 ）
类名与文件名一样
基础知识
一、标识符与关键字
1、标识符规则：
标识符由字母、下划线、美元符号和数字组成
首字符不能是数字
不能是关键字
不能是保留字true false null
2、关键字：
规则
关键字 byte short char 等
关键字都是小写的
private关键字
private：保护成员变量
this关键字
用来访问本类内容
this：当方法的局部变量（参数名）和成员变量重名的时候，根据就近原则，会优先使用局部变量，这个时侯就用关键字this来修饰成员变量
格式：this.成员变量
1、在本类的成员方法中访问本类的成员变量
2、在本类的成员方法中访问本类的另一成员方法
3、在本类的构造方法中，访问本类的另一构造方法
public class demo02 {
String name;//我自己的名字
public void haha(String name)//参数中的name是另外一个人的名字
{
System.out.println(this.name+"很爱"+name);
System.out.println(this);
}
}
public class demo0_2 {
public static void main(String[] args) {
demo02 one=new demo02();
one.name="小包包";
one.haha("大包包 ");
System.out.println(one);//
}
}
由运行结果可知，this的地址和demo02下的对象one具有相同的地址值
static关键字
如果一个成员变量或者成员方法使用了static关键字，那么这个成员变量或者成员方法不再属于该对象，而是属于所在类，多个对象共享同一份数据。
如果没有static修饰，则必须要创建对象才能调用。对象名.变量名
如果有static来修饰，则可直接通过类名称来调用。类名.变量名
public class Student {
String name;//普通成员变量，也叫做实例变量
String id;
public static String jiaoshi;//静态变量，也叫做类变量
public static void show()//静态方法，也叫做类方法
{
System.out.println("我是一个静态方法");
}
}
public class Demo01 {
public static void main(String[] args) {
Student stu1=new Student();
stu1.name="木分";
stu1.id="12345678";
stu1.jiaoshi="3班";//静态变量可通过对象名来调用，但编译时会翻译为类名.变量名
Student.jiaoshi="三班";
System.out.println("学生"+stu1.name+"的学号是"+stu1.id+",所在教室是"+ Student.jiaoshi);
Student stu2=new Student();
stu2.name="憨憨";
stu2.id="66666666";
System.out.println("学生"+stu2.name+"的学号是"+stu2.id+",所在教室是"+ Student.jiaoshi);
System.out.println("-----------------");
Student.show();//通过类名称来调用静态方法
}
}
//学生木分的学号是12345678，所在教室是三班
//学生憨憨的学号是66666666，所在教室是三班
//-----------------
//我是一个静态方法
public class Demo02 {
public static void main(String[] args) {
show();//调用本类中的静态方法可省略类名
System.out.println("------------------");
Demo02.show();//两者完全等效
}
public static void show()
{
System.out.println("我是个静态方法，我只执行啦");
}
}
注意事项：
1、静态不能访问非静态，但非静态能访问静态内容。因为在内存中是现有静态，再有非静态
2、静态方法中不能有this关键字
super关键字
用来访问父类内容
1、在在子类的成员方法中，访问父类的成员变量super.父类成员变量
2、在子类的成员方法中，访问父类的成员方法super.父类成员方法
3、在子类的构造方法中，访问父类的构造方法
instanceOf 关键字
在发生对象转型的时候，会出现错误 可以使用instanceOf关键字对象的判断 判断某个对象是否是某个类的实例
语法格式如下；
对象 instacneof 类名称 返回值 Boolean
Instanceof 判断一个对象是否是某个类的实例
public static void main(String[]args){
//A a =new A();
B b=new B();
A a=new B();
System.out.println(a instanceof A);
System.out.println(a instanceof B);
}
二、基本数据类型
boolean 声明逻辑变量 可赋初值 例boolean male=true
byte 内存分配1字节 8位
short 内存分配2字节 16位
char内存分配2字节
int 内存分配4字节 32位
long 内存分配8字节 64位
float 内存分配4字节 32位 后缀为f或F 保留8位有效数字 单精度
double 内存分配8字节 64位 后缀为d或D 后缀可省略 保留16位有效数字 双精度
取值范围
字符类型
char类型 ‘A’
转义字符常量 \'单引号
类型转换运算
低->高 自动转换
高->低 显示转换 int x=(int)34.89 不可以超出变量的取值范围
添加代码片段
输入输出数据
一、输入基本型数据
Scanner reader =new Scanner(System.in);
数组
1、特点
- 数组中的多个数据类型必须统一
- 数组属于引用型变量，数组名指向首元素的地址
- 数组声明和分配空间可以同时进行
2、数组的初始化
动态初始化
指定长度
格式：数据类型[] 数组名称=new 数据类型[数组长度]
float boy[]=new float[4]
静态初始化
指定内容
标准格式
float boy[]=new float[]{元素1，元素2，...}
省略格式
int[] arrayA={ };
数组索引越界异常
编译可通过，但运行不可以
如boy 只含四个元素 boy[4]=3.68f,
3、数组的引用
两个相同相同类型的数组如果具有相同的引用，他们就具
java程序的入口地址
public static void main(String[] args)
- java虚拟机运行程序的时候首先找的就是main方法.跟C语言里面的main()函数的作用是一样的.只有有main()方法的java程序才能够被java虚拟机欲行,可理解为规定的格式
- 对于里面的参数及修饰符
public:表示的这个程序的访问权限,表示的是任何的场合可以被引用,这样java虚拟机就可以找到main()方法,从而来运行javac程序
static:表明方法是静态的,不依赖类的对象的,是属于类的,在类加载的时候main()方法也随着加载到内存中去void main()方法是不需要返回值的String[] args:从控制台接收参数
对象 instanceof 类
当左边的对象是右边的类时，运算结果位true
加密解密原理
面向对象
需要完成某种任务时，首先要想到是谁去完成任务，即哪个对象去完成任务。提到数据，首先想到的是这个数据是哪一个对象的。
特征：
封装、继承、多态
一、封装性
封装就是将一些细节隐藏起来，对外界不可见
方法就是一种封装
关键字private也是一种封装
二、继承性
继承是多态的前提
继承主要解决问题：共性抽取
特点：
1、单继承 ：一个子类的直接父类只能有一个
2、多级继承：C——>B——>A C是B的子类，B是A的子类
3、一个父类可以有多个子类
定义一个父类
public class 父类名称
{
......
}
定义一个子类
public class 子类名称 extends 父类名称
{
......
}
注意事项：
在父子类继承关系中，如果成员变量重名，访问方式有两种。
1、直接通过子类对象访问成员变量
等号左边是谁，就优先用谁，没有，则向上找。
2、通过成员方法访问成员变量。
该方法属于谁，就优先用谁，没有，则向上找。
public class Fu {
String name;
public void methodFu()
{
System.out.println("父类方法执行啦");
}
public void method()
{
System.out.println("父类重名方法方法执行啦");
}
}
public class Zi extends Fu{
String something;
public void methodZi()
{
System.out.println("子类方法执行啦");
}
public void method()
{
System.out.println("子类重名方法方法执行啦");
}
}
public class demo03 {
public static void main(String[] args) {
Fu fu=new Fu();
Zi zi=new Zi();
zi.name="憨憨";//子类可以用父类的成员变量
zi.something="我不是憨憨";
System.out.println(zi.name+"想说"+zi.something);
System.out.println("===================");
zi.methodFu();//子类可以调用父类方法
zi.methodZi();//子类调用子类方法
fu.method();//创建的是父类对象，所以优先用父类方法
zi.method();//创建的是子类对象，所以优先用子类方法
}
}
继承中，父子类构造方法的访问特点
1、子类构造方法中有一个默认的“super()"调用，所以一定是先调用父类构造，再调用子类构造方法
public class Fu {
public Fu(){
System.out.println("父类构造方法执行啦");
}
}
public class Zi extends Fu{
public Zi()
{
System.out.println("子类构造方法执行啦");
}
}
public class demo03 {
public static void main(String[] args) {
Zi zi=new Zi();
}
}
2、子类构造可通过关键字super调用父类重载构造
只有在子类构造方法中，才能调用父类构造方法
public class Zi extends Fu{
public Zi()
{
//super()在调用父类无参构造
super(10);//调用父类有参构造方法
System.out.println("子类构造方法执行啦");
}
}
3、super的父类构造调用，必须是子类构造方法的第一个语句，不能一个子类构造调用多个super构造
三、多态性
1、多态的理解
多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口，使用不同的实例而执行不同操作。
2、多态的体现
父类引用变量可以指向子类对象。
注意：在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法。
3、多态的定义与使用格式
定义格式：父类类型 变量名=new 子类类型();
多态的向上转型
Shape s=new Circle();
new谁就是为谁开辟空间 为谁创建对象
这里 创建了一个Circle对象，并把得到的引用立即赋值给Shape。通过继承，Circle就是一种Shape。
假设调用基类方法（它已在导出类中被覆盖）：
s.draw();
由于后期绑定（多态），将会正确调用Circle.draw()方法
Java中的跨类引用
-
如果a是类A的一个引用,那么,a可以指向类A的一个实例。或者说指向类A的一个子类，这是向上转型的情形。
-
如果a是接口A的一个引用,那么,a必须指向实现了接口A的一个类的实例。这是接口回调的情形。
多态的向下转型
在java里面,向上转型是自动进行的,但是向下转型却是强制的,
子类转型成父类是向上转型，反过来说，父类转型成子类就是向下转型。但是，向下转型可能会带来一些问题：我们可以说麻雀是鸟，但不能说鸟就是麻雀
限制 :向下转型时必须先向上转型 转型过程中必须发生关系
class B extends A{}
public class A {
public static void main(String[] argts){
A a1=new A();
A a2=new B(); //Upcasting向上转型
B b1=new B();
B b2=(B) new A();//DownCasting向下转型,[注意]:此处(B)进行了强制转换!
}
}
类
Java的最重要“数据类型”
1、书写格式
class 类名
{
类体的内容;
}
类名首字母大写
class是关键字 用来定义类。
2、构成
类体由两部分构成：
1、变量的声明；//此处的变量为成员变量
2、方法的定义 成员方法无static
public class Lei {
String name;//成员变量，定义在类中，成员方法之外
public void haha()//成员方法不用加关键字static呀
{
System.out.println("这是成员方法呀");
}
}
3、成员变量和局部变量
局部变量：在方法体中定义的变量和方法的参数，无默认值，只在方法内有效
成员变量：定义在方法外，直接写在类中，有默认值，在整个类中都有效
class InitError{
int x=10,y;//y的默认值为0
void f(){
int m;//m是局部变量，没有默认值，编译不能通过
x=y+m;
}
4、实例变量和类变量
从Java程序的角度来看，static的作用就是将实例成员变为类成员。
使用static修饰的成员变量是类变量，属于该类本身；没有使用static修饰的成员变量是实例变量，属于该类的实例。
实例变量属于Java对象本身，每次程序创建Java对象时都需要为实例变量分配内存空间，并执行初始化。访问方法：
类变量属于该类本身，只要改类初始化完成，程序即可使用类变量 调用方法：类名.类变量
实例方法
类方法有static关键字修饰，也叫做静态方法。
对象
类不能直接使用，需要根据类创建一个对象，才能直接使用。
1、导包
指出需要使用什么类，在什么位置
import 包名称.类名称
若需要的类和当前类属于同一个包，则可以省去导包步骤。
2、创建
类名称 对象名=new 类名称();
3、使用
使用成员变量或成员方法 用谁点谁 即想用谁，就用对象名点谁
public class Lei {
String name;//成员变量，定义在类中，成员方法之外
String myname="mufen";
public void haha()//成员方法不用加关键字static呀
{
System.out.println("这是成员方法呀");
}
}
public class Duixiang {
public static void main(String[] args) {
Lei myfirstduixiang=new Lei();//创建一个名为myfirstduixiang的对象，此对象的类为 Lei
System.out.println(myfirstduixiang.name);
System.out.println(myfirstduixiang.myname);
myfirstduixiang.haha();
myfirstduixiang.name="木分";//可以对成员变量重新赋值哦
System.out.println(myfirstduixiang.name);
}
}
/*null
mufen
这是成员方法呀
木分
*/
4、一个对象的内存图
5、两个无关对象的内存图
6、两个对象引用指向同一个对象空间
7、使用对象类型作为方法的参数
当一个对象作为参数传递到方法中时，实际传递的是对象的地址值
public class Demo17 {
public static void main(String[] args) {
Lei one=new Lei();//创建一个名为one的对象
one.name="憨憨";
one.myname="木分";
method(one);//把one的地址传递给method
}
public static void method(Lei duixiang)//以对象作为参数 把地址扔给方法中进行使用
{
System.out.println(duixiang.name);
System.out.println(duixiang.myname);
duixiang.haha();
}
}
8、使用对象类型作为方法的返回值
当以一个对象类型作为方法的返回值时，返回值就是这个对象的地址值
public class Demo17_2 {
public static void main(String[] args) {
Lei two=getOne();//将getOne的返回值赋值给了two，这个时候对象two的地址便和对象one的地址一样了┗|｀O′|┛ 嗷~~
System.out.println(two.name);
System.out.println(two.myname);
}
public static Lei getOne()
{
Lei one=new Lei();
one.myname="木分";
one.name="hanhan";
one.haha();
return one;//以对象类型作为返回值
}
}
基本数据类型和封装类的区别
在赋值上，两者没有区别；
在使用上，封装类可以直接调用方法，而基本数据类型不可以。
一般局部变量使用基本数据类型，而实例变量使用封装类。
eg：
ASCII编码
48 0
65 A
97 a
方法
1、格式
无返回值类型
只能进行单独调用
public static void 方法名（）
{.....}
有返回值类型
修饰符 返回值类型 方法名称 （参数类型 参数名称，...）
{
方法体
return 返回值；
}
修饰符一般为public static
2、调用
单独调用
方法名（参数）;
打印调用
（需要显示返回值结果的时候用它）
System.out.println(方法名(参数));
赋值调用
数据类型 变量名称=方法名称（参数）；
四步骤：找到方法、参数传递、方法执行、将结果返回调用处
public class Fangfa {
public static void main(String[] args)
{
//直接调用
System.out.println("直接调用结果为");
sum(10,20);
//打印调用
System.out.println("打印调用结果为");
System.out.println(sum(10,20));
//赋值调用
System.out.println("赋值调用结果为");
int result=sum(10,20);
System.out.println(result);
}
//方法
public static int sum(int a,int b){
int result=a+b;
System.out.println("函数调用成功啦");
return result;
}
}
方法应定义在类中，方法中不能再定义方法
3、方法重载(Overload)
名称相同，参数列表不同
不同可以是参数个数不同，类型不同
优点：可以使用同一个方法名称，实现相似的多种方法
public class FangfaChongzai {
public static void main(String[] args) {
System.out.println(sum(10,20));
System.out.println(sum(10,20,30));
System.out.println((sum(10.7,20.6)));
}
public static int sum(int a,int b)//两个参数的方法
{
int result=a+b;
return result;
}
public static int sum(int a,int b,int c)//三个参数的方法
{
int result=a+b+c;
return result;
}
public static int sum(double a,double b)//参数类型不同的方法
{
int result=(int)(a+b);
return result;
}
}
更改变量名称快捷键 shift+F6
4、get&set方法
public class Person
{
private String name;
private int age;
private boolean male;
//定义年龄时，无法阻止不正常的数据设置进来，此时就用private关键字来修饰需要被保护的成员变量
// 当要在其他类访问此私有成员变量时，就要用特殊的方法进行访问问。
//set函数可修改成员变量的值，对数据进行合理性判断
public void setAge(int age)
{
if(age>=0&&age<120)
{
this.age = age;
}
else
{
System.out.println("数据输入错误");
}
}
//get函数专门用于获得成员变量的数据
public int getAge()
{
return age;
}
public void setName(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
public void setMale(boolean male)
{
this.male = male;
}
//boolean类型获取数据时is而非get
public boolean isMale()
{
return male;
}
}
public class demo01
{
public static void main(String[] args) {
Person person1=new Person();
person1.setName("憨憨");
person1.setMale(true);
person1.setAge(18);
System.out.println("我的名字是"+person1.getName());
System.out.println("我的年龄是"+person1.getAge());
System.out.println("我可不可爱？"+person1.isMale());
System.out.println("---------------");
Person person2=new Person();
person2.setName("灭亡");
person2.setMale(true);
person2.setAge(1000);//数据输入不合理
System.out.println("他的名字是"+person2.getName());
System.out.println("他的年龄是"+person2.getAge());
System.out.println("灭亡帅不帅？"+person2.isMale());
}
/*
我的名字是憨憨
我的年龄是18
我可不可爱？true
----------------
数据输入错误
他打的名字是灭亡
他的年龄是0
灭亡帅不帅？true
*/
5、构造方法
专门用来创建对象，如当我们通过关键字new来创建对象时，其实就是在调用构造方法。
格式
public 类名称（参数类型 参数名称）
{
方法体
}
注意事项
（1）构造方法的名称必须与类名称一模一样。
（2）构造方法不要返回值类型，void也不需要。
（3）构造方法不能return一个具体的返回值。
（4）如果没有编写任何构造方法，编译器将赠送一个默认的无参数构造方法。
（5）一旦编写了至少一个构造方法，编译器将不再赠送无参数的默认构造方法，此时要将此默认的构造方法写上去。
（6）构造方法是可以重载的，方法名称相同，参数列表不同。可通过带参数的构造方法进行传值，就可以省去get set方法。但是如果要获取数据，就要再加get。如果要改变成员变量数据内容，就还要加set方法
public class Student
{
String name;
int age;
public Student()//无参数的构造方法
{
System.out.println("构造方法执行啦");
}
public Student(String name,int age)//含参数的构造方法
{
System.out.println("全参构造方法执行啦");
this.name=name;
this.age=age;
}
//set方法用于修改变量数据
public void setAge(int age)
{
this.age = age;
}
//get方法用于获取成员变量数据
public int getAge()
{
return age;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
}
public class Gouzao
{
public static void main(String[] args)
{
Student stu=new Student();//调用无参数的构造方法
stu.name="灭亡";//对变量进行赋值
stu.age=0;
System.out.println(stu.name+stu.age);
System.out.println("-----------");
Student stu2=new Student("木分",18);//调用含参数的构造方法，直接将值传递进去
System.out.println(stu2.getName()+"的年龄是"+stu2.getAge());
System.out.println("---------------");
stu2.setName("憨憨");//对name进行修改
stu2.setAge(5);//对age进行修改
System.out.println(stu2.getName()+"的年龄是"+stu2.getAge());//打印修改后的值
}
}
6、方法覆盖重写（Override)
在继承关系中，方法名称一样，参数列表相同
子类方法的返回值范围必须小于等于父类方法的返回值范围
子类方法的权限必须大于等于父类方法的权限
public class Phone {
public void call()
{
System.out.println("打电话");
}
public void send()
{
System.out.println("发短信");
}
public void show()
{
System.out.println("显示号码");
}
}
public class NewPhone extends Phone{
@Override//用来检查是否覆盖重写正确
public void show()
{
super.show();//把父类方法拿来重复利用
//自己再添加更多内容
System.out.println("显示名字");
System.out.println("显示头像");
}
}
public class Demo04
{
public static void main(String[] args) {
Phone phone =new Phone();//旧手机功能
phone.call();
phone.send();
phone.show();
System.out.println("=================");
NewPhone newphone =new NewPhone();//新手机功能
newphone.call();
newphone.send();
newphone.show();
}
}
抽象
1、抽象类
public abstract class 类名{...}
抽象类中可以有构造方法，供子类创建对象时，初始化父类成员
抽象类不一定有抽象方法
抽象类的子类必须覆盖重写父类的所有抽象方法
2、抽象方法
：如果父类当中的方法不确定如何进行方法体的实现，那么这个方法应该是抽象方法
public abstract void 抽象方法名();
抽象方法必须定义在抽象类中
3、如何使用抽象类和抽象方法
1、不能直接创建new抽象类对象
2、必须用一个子类来继承抽象父类
3、子类必须覆盖重写抽象父类的所有抽象方法
覆盖重写的实现：子类去掉抽象方法中的abstract关键字，补上方法体大括号
4、创建子类对象进行使用
接口
接口就是多个类的公共规范
接口是一种重要的引用数据类型，最重要的内容就是其中的抽象方法。
1、格式
public interface 接口名称{...}
2、内容
常量
public static final 数据类型 常量名称=数据值;
常量名称完全大写，用下划线进行分隔，必须赋值
抽象方法
抽象方法格式：
public abstract 返回值类型 方法名称(参数列表);
public abstract可选择性的省略
注意：实现类必须覆盖重写接口中的所有抽象方法，除非实现类是抽象类。
默认方法
public default 返回值类型 方法名称（参数列表）{...}
默认方法也可以被覆盖重写
静态方法
public static 返回值类型 方法名称（参数列表）{...}
注：应通过接口名称调用，不能通过实现类对象名调用
私有方法
private 返回值类型 方法名称（参数列表）{...}
私有方法只能接口自己调用，不能被实现类或其他类调用。
使用接口时应当注意：接口没有静态代码块或者构造方法，一个类的直接父类是唯一的，但是一个类可以同时实现多个接口
3、使用步骤
接口不能直接使用，必须要有一个实现类来实现该接口
public class 实现类名称 implements 接口名称{...}
接口实现类必须覆盖重写接口中的所有抽象方法。
- 如果实现类实现的多个接口中存在重复的方法，那么只需要覆盖重写一次即可。
- 如果实现类实现的多个接口当中存在重复的默认方法，那么一定要对冲突的默认方法进行覆盖重写
若需要调用实现类中的已覆盖方法，则需进行接口回调
4、 接口回调
可以把实现类创建的对象的引用赋给该接口声明的接口变量，那么该接口变量就可以调用实现类的方法。实际上，当接口变量调用实现类中的方法时，就是通知相应的对象调用接口的方法，这一过程称为对象功能的接口回调
接口名=对象名;//声明接口变量
对象名=new 实现类名称;
对象名.实现类中的接口方法;//接口回调
interface People {
void peopleList();
}
class Student implements People {
publicvoid peopleList() {
System.out.println("I’m a student.");
}
}
class Teacher implements People {
publicvoid peopleList() {
System.out.println("I’m a teacher.");
}
}
publicclass Example {
publicstaticvoid main(String args[]) {
People a; // 声明接口变量
a = new Student(); // 实例化，接口变量中存放对象的引用
a.peopleList(); // 接口回调
a = new Teacher(); // 实例化，接口变量中存放对象的引用
a.peopleList(); // 接口回调
}
}
//结果
//I’m a student.
//I’m a teacher.
ArrayList集合
一、概念
二、基本使用
//创建了一个ArrayList集合，集合名称是list，里面装的全是Strig类型数据
ArrayList<String> list=new ArrayList<>();
System.out.println(list);//此时内容为空，打印的结果为[]
三、常用方法
1、public boolean add(E e)方法：向集合中添加元素，参数的类型和泛型一致。
注：对于ArrayList集合来说，add的添加动作一定是成功的，所以返回值可用可不用，但是对于其他集合来说，add的添加动作不一定成功。
ArrayList<String> list=new ArrayList<>();
System.out.println(list);//此时内容为空，打印的结果为[]
//往集合中添加内容,用add方法
list.add("今天要快快乐乐度过呀");
System.out.println(list);//打印结果：[今天要快快乐乐度过呀]
list.add("好呀");
System.out.println(list);//打印结果：[今天要快快乐乐度过呀, 好呀]
boolean success=list.add("xixi");
System.out.println("添加动作是否成功？");
System.out.println(success);//true
System.out.println(list);//[今天要快快乐乐度过呀, 好呀, xixi]
2、public E get(int index)方法：从集合中获取元素，参数是索引编号，返回值就是对应位置的元素。
3、public E remove(int index)方法：从集合中删除元素，参数是索引编号，返回值就是被删除的元素。
4、public int size()方法：获取集合的尺寸长度，返回值是集合中包含的元素。
四、遍历
扫一扫
19万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
