java基础 oop知识点

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 父类 或 父类接口( ){
//需要重写父类或接口方法
}；