long = 12123L
folat = 1.3f;
类型转换
byte shout char int long float double
从低 到高 不需要强制转换
变量
实例变量
局部变量
publi{ 生命周期 }
类变量
static 中调用
final 一般定义始终不变的常量
Static final double PI = 3.14;
++ -- 自增 自减
幂运算 Math.pow(2,3) == 2^3
位运算
& 如果都是1则为1 否则为0
| 如果都是0则为0 否则为1
^异或 相同则为0 不同为1
~取反 相反
<<左移 *2
>>右移 /2
字符串连接符+
”“+ 12+3 = ”123“
12+3+”“ = "15"
三元运算符
x ? y :z x==true 返回y 否则 返回z
包机制
import 导入包
import ...*通配符 导入...包下的所有
javadoc -encoding UTF-8 -charset UTF-8 HelloWord.java
Scanner sc = new Scanner(System.in);//从键盘接受数据
System.out.println("使用next方式接受");
if (sc.hasNext()){ //判断是否有输出
String str = sc.next(); // 接受
System.out.println("输出的内容为"+str);
}
//凡是属于IO流的类如果不关闭会一直占用资源
sc.close();
Scanner 类 next() nextLn() 区别
next() 一定要读取到有效字符后才可以结束 输入之前遇到的空格忽略 输入有效字符后 遇到空格会结束执行
nextLn() 以Enter 为结束符 也就是说 nextLn() 方法返回回车之前的所有字符
Switch语句
要加break
do {} while() 先进循环体 再判断条件
foreach 遍历数组 或者 arrays.toString(数组名称)
int[] num = {}定义数组
重载 一个类两个相同名字的方法 但参数列表(个数 类型 参数排列顺序)必须不同 返回类型可以相同也可以不同
理论 方法名称相同时。编译器会根据调用方法的参数个数,参数类型等逐个匹配,已选择对应的方法,如果匹配失败则编译器会报错
可变参数
int [] nums;
nums = new int[10];
声明在栈中 赋值在堆内存。
静态初始数组
int [] a = {1,2,3,4};
动态初始
int [] b = new int[10];
b[0] = 1;
数组排序 Arrays.sort(数组名称);
判断数组相同 Arrays.equals()
查找数组某个值的索引位置Arrays.binarySearch(数组名称, key)
Arrays.fill() 将数组所有值赋值 或者从第几位到某一位的值赋值
Arrays.toString () 遍历数组
八大排序
冒泡排序 :外层 控制层数 里层比较
public static void bubble(int[] a){
int temp;
for (int i = 0; i < a.length-1; i++) {
flag = true;
for (int j = 0; j < a.length-1-i; j++) {
if (a[j]>a[j+1]){
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
if (flag){
break; //优化冒泡 加锁;
}
}
}
oop
构造器 :使用new关键字 必须要有构造器 且 如果具有有参构造器 必须有无参构造器
类和对象
类 仅仅是设计模板 而对象是实现
成员变量 可以被局部变量使用 反之不可以
复习内存图
面向对象 ====封装 继承 多态
private 私有化变量之后 这个变量不能在类外访问 如果private修饰成员方法则不能在类外使用该方法
正因为有了封装 set get 方法 则可以对成员变量进行控制
this 的作用
1 当成员变量和局部变量重名的时候 this 可以用来区分 成员变量和局部变量
2 方法中的this 会指向调用该方法的对象
继承 可以提高代码的复用性
2 继承是多态的前提
b 注意事项
java只支持单继承 不支持多继承
java 一个父类可以有多个子类 //一个父亲可以有多个儿子
java规定 最顶层的类继承的是 object类 extends object
访问特点具有就近原则 子类如果没有 会继续查找父类
通过this 可以调用本类成员
通过super 可以调用父类成员
-------------------------------------------------
重写的必要条件 @Override // 重写标记 (注解) 强制子类的方法重写父类的方法 , 如果不重写就报错 目的是为了防止忘记重写
a 重写必须要有继承关系 , 重写针对的是子类的方法重写父类的方法
b 子类的方法与被重写的父类的方法要保持一致 (参数列表)
c 子类的方法权限>= 父类被重写的方法的权限
public 默认 protected private
最大权限是public
最小权限是private
private 修饰的方法不被重写private 一旦修饰弗雷德方法只能父类自己使用
子类根本获取不到也就无法被重写
==
重载 重写区别
重载 :
public void show(int i) {
}
public void show (double j ) {
}
重写
public void show (double j ) {
}
public void show (double j ) {
}
重载 : 对修饰符没有要求
重写: 权限要求
******************************************************
抽象方法 引入
如果这个方法体无法确定 我们需要把这个方法定义为抽象方法
修饰符 abstract 返回值类型 方法名 (参数列表);
抽象类引入:
一旦一个类有抽象方法 那么这个类必须是抽象类
抽象类无法创建对象 因为抽象类里面的抽象方法调用没有意义
抽象类一般作为体系的规范, 约束子类必须实现父类的某些方法
我们一般不直接使用抽象类 而是通过创建它的子类对象使用
----------------------------------------------------------------------
接口的概述
接口也是一种引用数据类型
java 中的引用数据类型有 类 数组
引用数据类型可以赋值null 或者对象 (对象在内存中的地址)
b 接口的出现是为了弥补java中只有单继承的不足
接口格式
class 类名{
成员变量
成员方法
}
interface 接口名 {
成员变量
成员方法
}
接口和抽象类一样都不能实例化对象
class 类名 implements 接口名{
}
接口编译之后 也是生成接口名.class文件
接口中的成员变量加的有默认修饰符
public static final
static 修饰的成员可以通过类名或者接口名 直接调用 类名/接口名.成员变量
final 修饰的变量都是常量 (final 修饰的变量只能赋值一次)
interface 类中 方法如果不加default 则默认为 抽象方法
同抽象类 一致 需要继承 并重写该方法 若加上default默认方法 当继承该类时不需要重写方法 但是可以被重写
为什么要存在default默认方法呢 ?
JDK1.7版本
当我们添加一个新方法到接口中 所有子类都必须重写这个方法 保证编译通过
JDK1.8版本
在接口中定义default默认方法 则子类不需要在重写该方法 就可以使用 这就大大提高了代码的复用性
interface A{
void show(){} //默认为抽象方法
}
?? interface 下 private 定义方法 jdk版本必须在8以上 只能在该类中使用
多态 (首先要继承)
向上转型 (子类型)可以自动提升为父类型
父类型引用变量名 = new 子类();
不能将父类型赋值给子类型
例子:
Teacher teacher = new Teacher();
Person p = new Teacher(); //现实中存在一位老师 我们把它称作为人
向下转型 : 子类型 引用变量 = (子类型) 父类型引用变量
Person p = new Student(); //向上转型 (自动类型提升)
Student s = (Student) p; //需要强转
这个例子中只有一个学生对象
但是这个学生扮演了两种角色 分别是人和学生
当扮演人的角色时就具有人的行为
当扮演学生的角色时就具有学生的行为
多态中成员变量访问特点:
**无论编译时期还是运行时期都参照赋值符号左边的类型
在多态运行时期 会去找赋值符号左边的类型(father)中变量执行
多态中成员方法的访问特点 :
编译时期:会去检测赋值符号左边的类型中是否有该方法 如果有 编译通过 如果没有编译失败
运行时期:会去检测赋值符号右边的类型中是否有该方法 如果有 直接执行 如果没有 会去执行父类中的此方法
**编译时期看赋值符号左边类型 运行时期看赋值服号右边类型
instanceof 运算符
A instanceof B 检测 引用变量指向的对象能否赋值给右边类型
Dog dog = new Dog();
dog instanceof Dog //true;
dog instanceof Animal // true Animal temp = new Dog();
个人理解 : 就是检测A 与 B 是否有继承关系
B 继承 A
构造方法
public 类名(){}
当实例化对象的时候 先执行的是 构造方法
一个类中 如果不写传参构造方法 类中默认有空参构造方法
this语句在构造器中使用 只能放在构造器的第一行
** this(参数) 调用的是本类构造方法
super() 默认存在 子类继承父类 中 子类的构造方法中 自动调用父类的空参构造器
super(参数) 调用父类有参构造器
super 语句也必须放在第一行
同一个构造方法中 this(参数)语句 和super(参数)语句只能有一个
但是 有了this 之后难道就不能调用父类方法吗?
答: this调用的方法中仍然可以有super(参数) 构造器中默认有该方法
所有子类的构造方法一定会调用 父类的构造方法
最顶层的类 会调用 Object类
final 关键词 修饰类后 就不能被继承了
如果修饰变量 那么这个变量只能被赋值一次
final修饰的方法 不能被子类重写
static 静态变量 直接用类名字就可以调用 推荐***
静态修饰成员方法
静态成员和类同生共死 非静态成员 和对象同生共死
static 修饰的变量 在方法区
静态成员变量的特点: 只有一个 且共享
静态方法 不可以访问非静态成员变量 但是非静态 既可以访问静态成员又可以访问非静态成员
比喻:静态 == 古人 非静态 == 21世纪人
public static final 常量名字 = 值
包机制::
导包 import
同一个包下的类直接用 不同包时需要导包
权限修饰符
public 默认 protected private
同一个包 √ √ √ √
同一个包下的不同类 √ √ √ ×
不同包下的两个类 √ × × ×
不同包下的子父类 √ × √ ×
private 修饰的成员只能在本类中使用
public 权限最大 它适合夸包访问
protect 如果父类成员加了protect 修饰 那么只有它的子类可以使用
匿名类
new 类名 不赋值
在 new 类名 时 就相当于 有实例化了一个对象
使用场景 匿名对象 主要用在方法传参 并且只使用一次
代码块
局部代码块
: 限制代码的使用范围 只能在代码块内使用
构造代码块
: 构造代码块 随着对象的创建被执行 ,而且代码构造块优先于构造函数执行
**静态代码块
随着类的加载而执行
只要用到这个类 静态代码块就执行
静态代码块先执行 并且只执行一次---> 构造代码块-----> 构造函数
jar包 用的时候在学;
引用类型作为方法的形参和返回值 day14
内存分析图 普通类作为方法的返回值
抽象类作为方法的形参 只能接受子类对象 本质上 接受的时子类对象的地址值
在该方法中使用这个形参 遵循多态原则
当抽象类走位方法的返回值类型时候 只能返回子类对象 本质上返回的时子类对象的地址值
在返回到调用出使用引用变量 依然遵循多态原则
接口作为方法的形参 和返回值
接口作为方法的形参 只能接受实现类对象 本质上 接受的是实现类对象的地址值
在该方法中使用这个形参 遵循多态原则
当接口作为方法的返回值类型时候 只能返回实现对象 本质上返回的时实现对象的地址值
在返回到调用出使用引用变量 依然遵循多态原则
内部类
实现 :: 外部类.内部类
内部类 顾名思义就是在一个类的内部定义一个类
因为有些事物内部还含有其他食物,因此我们需要通过内部类的形式更加贴近于现实生活描述
内部类 第一种实例化方式:Person.Heart p = new Person().new Heart();
第二中 是 public Heart getHeart(){
return new Heart();
}
class Heart{
//内部类
private int i = 4;
public void method(){
int i = 7;
System.out.println(i);
System.out.println(this.i);
System.out.println(Person.this.i);
}
局部内部类 :定义在局部位置 就是定义在方法中 形式为: 外部类&编号 类名.class
成员内部类 外部类&类名 .class 没有编号
匿名内部类 在继承接口中 后使用
格式 : new 父类 或 父类接口( ){
//需要重写父类或接口方法
};