常量 final 常量类型 大写命名 常量值不允许被更改
//java程序运行 必须有main方法 这是程序的入口
public static void main(String[] args){}
java数据类型:
基本数据类型:
数值类型(六种):
整数:byte: -128~127 -2^7~2^7-1 一个字节
short(基本不用): -32768~32767 -2^15~2^15-1 两个字节
int(最常用): -2,147,483,648（-2^31）~2,147,483,647（2^31 - 1） 四个字节
long: -9,223,372,036,854,775,808（-2^63）~9,223,372,036,854,775,807（2^63 -1） 八个字节
浮点数:float:保留6~7位小数 四个字节
double:保留6~15位小数 八个字节
非数值类型(两种):
boolean:true/false 1bit
char:字符 一个字符 0~65535 4个字节
引用数据类型:String类型.....
* 字符串:String
* 引用数据类型
* 一串类型
* 单个是char
//比较字符串是否相等 只比较内容
System.out.println(str0.equals(str1));
// 字符串提取
//indexOf()第一个出现的字符
System.out.println(str0.indexOf("兵"));
//lastIndexOf()最后一个字符
System.out.println(str0.lastIndexOf("兵"));
//substring(m,n)从m开始到n结束
//substring(m)从m开始到结束
System.out.println(str0.substring(2,6));
* 单位:
* 1bit(比特)
* 1byte(字节) = 8bit
* 1kb =1024b(byte)
* 1mb =1024k
* gb => tb => pb
流程控制:
* 1.顺序控制:
* 程序从上到下 从左到右依次执行
* 2.选择流程:
* 判断:if
* if(条件表达式){
* 执行语句块;
* }else{
* 当条件表达式不成立,执行的语句块;
* }
* 选择:switch
* switch(变量名){
* case 值1:
* 当变量名值为值1时,执行的语句块;
* break;
* case 值2:
* 当变量名值为值2时,执行的语句块;
* break;
* case 值3:
* 当变量名值为值3时,执行的语句块;
* break;
* case 值4:
* 当变量名值为值4时,执行的语句块;
* break;
* ...
* default:
* 上面所有不成立,执行的语句块;
* break;
* }
* 3.循环流程:
* while:先判断再执行
* while(条件表达式){
* 循环语句块;
* }
* do...while:先执行再判断
* do{
* 循环语句块;
* }while(条件表达式)
* for:
* for(初始化变量;条件表达式;更新变量){
* 循环语句块;
* }
//键盘输入类 获取控制台输入的内容
Scanner sc = new Scanner(System.in);
//获取输入内容
// int num = sc.nextInt();
// * 数组:Arrey
// * 定义:数组是一个变量,存储相同数据类型的一组数据
// * 特点:
// * 1.数组本身引用数据类型,但是里面的元素可以是基本也可以是引用
// * 2.数组里元素类型必须一致
// * 3.数组如果规定长度,长度固定
// * 基本要素:
// * 标识符:数组的名称,用于区分不同数组(数组名)
// * 数组元素:数据
// * 元素下标:数组内元素进行编号,从0开始
// * 元素类型:数组元素的数据类型
// */
//
// /*
// * 创建数组的步骤:
// * 1.声明数组
// * 2.开辟空间
// * 3.赋值
// * 4.使用数组
// */
// //1.声明数组
// int arr[];
// //2.开辟空间
// arr = new int[10];
//
// //正常的创建数组 第一二步合并 int arr[] = new int[10];
//
// //3.赋值
// arr[0] = 5;
// arr[1] = 6;
// arr[2] = 7;
// //4.使用数组
// int sum = arr[0] + arr[1] + arr[2];
//
// //遍历数组
// for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
// }
// /*
// * 数组默认值:
// * int byte short long char 都是0
// * float double 是0.0
// * boolean 是false
* 构造函数:
* 1.初始化对象属性
* 2.优先级很高
* 3.构造函数的方法名和类名相同
* 4.构造函数没有返回值,没有void
* 5.构造函数可以不写,系统会默认一个无参构造器
* 6.当有一个构造器后,系统默认的无参构造器会自动删除
*/
/*
* static:静态的
* 修饰变量 : 是全局变量,通过类名.属性名直接调用,当本类被加载时,变量就初始化完成
* 修饰方法 : 是静态方法,通过类名.方法名直接调用,当本类被加载时,方法就初始化完成
*
* 变量:
* 全局变量:隶属于类的,整个项目中都能直接访问的变量 静态变量 static
* 成员变量:隶属于对象的,只有在对象创建以后同构对象调用
* 局部变量:隶属于变量所在的代码块,只作用在当前代码块中
*
* this:
* this指向成员变量 为了区分局部变量与成员变量同名的问题
*/
/*
* 形参:
* 形式参数,没有具体的值,只作为变量名的引用,常见于方法参数
* 实参:
* 实际参数,有值,就是一个常见的变量
*
*
*
* 值传递:
* 只是传递值的复制品,原来的值不会发生改变
*
* 引用传递:
* 因为引用的是同一个对象的地址,所以当对象内容改变时,所有的引用都会变
*
*对象的生命周期:
* new --> 对象被创建初始化
* 赋值与使用 --> 对象的调用
* 销毁 --> 当这个对象没有被任何变量引用时,java回收机制进行垃圾回收,对象销毁
//无参构造器
public Demo004() {
//this指向成员变量 -->对象的变量
this.name = "张三";
this.age = 18;
this.sex = "男";
this.idNum = 121212;
System.out.println("我是无参构造器");
}
//有参构造器
public Demo004(String name,int age,String sex,int idNum){
//带this的是前面的 后面的是构造器传进来的
this.name = name;
this.age = age;
this.sex = sex;
this.idNum = idNum;
}
* java中的方法类型: 只要是无返回值 public后面是void(无返回值类型)
* 无参无返 public void 方法名(){方法体;}
* 无参有返 public 返回值类型 方法名(){
* 方法体;
* return 返回值(与前面类型对应);
* }
* 有参无返 public void 方法名(参数类型1 参数名,参数类型2 参数名,...){
* 方法体;
* }
* 有参有返 public 返回值类型 方法名(参数类型1 参数名,参数类型2 参数名,...){
* 方法体;
* return 返回值;
* }
* 面向对象的特点:
* 封装:
* 信息的隐藏,通过指定的方法进行访问调用
* 访问控制修饰符:
* 本类中 同包下 不同包子类中 不同类不同包中
* public 公共的 √ √ √ √
* protected 受保护的 √ √ √ ×
* 不写 默认的 √ √ × ×
* private 私有的 √ × × ×
* 继承:
* 子类继承父类的非私有的属性和方法
* 继承:
* 1.提高代码复用性
* 2.使类与类之间有了层级关系
* 3.子类继承父类的非私有属性和方法
*
* super:
* 指向的是父类的成员变量
* this:
* 指向的是本类的成员变量
*
* super(); 调用父类的构造器,必须写在子类构造器第一行
* super不能与static连用
* 多态:一种事物的多种形态
* 前提条件:一定是在继承关系中
//用父类的引用类型 指向子类的对象 --> 多态
Day07duotai02 d = new Day07duotai();
* 抽象: abstract
* 抽象类 抽象方法
* 1.被abstract修饰的类叫抽象类,方法同理
* 2.抽象类不能被实例化(new) 但是抽象类中有构造器
* 3.抽象类的创建是创建他的子类
* 4.子类必须实现抽象父类中的所有抽象方法,否则这个子类也是抽象类
* 5.抽象方法只需声明,不用实现
* 6.抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类
* 7.abstract 不能和static,final(不能被继承,但是本身可以继承于一个父类,修饰的方法不能被重写,修饰的属性是常量),private连用
*
* 接口 interface
* 类名 implements 接口名 实现子类
* 是一个独立的数据类型
* 也是一个特殊的抽象类
* 1.接口中的方法都是抽象方法
* 2.接口中的所有属性都是静态常量
* 3.接口是不能被实例化的,接口中没有构造器
* 4.接口可以多继承 多实现的
* 5.接口的实现子类必须实现所有接口父类的所有抽象方法否则这个子类就是一个抽象类
* 6.接口中的方法默认被 public,abstract修饰
* 7.接口中的属性默认被public,static,final修饰
* 接口只是一种规范
*方法的重载:
* 1.在同一个类中,方法名相同
* 2.参数不同(类型,类型顺序,个数)
* 3.返回值类型无关
* 4.访问控制修饰符一致
* 方法的重写:
* 1.必须在继承关系中,子类重写父类的方法
* 2.方法名相同
* 3.返回值类型相同
* 4.子类的控制修饰符范围大于等于父类的
* 5.参数相同(个数,类型,顺序)
*
* override:
* 程序自动检测重写的方法是否正确 如果不正确,会报错
* 如果重写的方法不加override,但是重写的格式错误,会成为子类独有的方法,不再涉及父类方法
262
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
