61.【JavaSE 《StudyKuang》】

1.包的规范:

我们通常把公司的域名倒置过来，作为包的名字.

2.导入包的规范

如果我们把一个类，导入一个我们自定义的包中的时候。那么我们的JDK会自动生成对应包的名字。

3.引入包的规范

import <引入的包名>.<引入的类>

4.Scanner的规范

1.判断是否还有键盘输入

Scanner scanner=new Scanner();
scnner.hasNext() 或则  scnner.hasNextLine()
 

2.Scanner 用完之后要关闭h，否则占用内存

Scanner scanner=new Scanner();
scnner.close();

5.三角形的操作

6.方法的重载

1.方法的名字必须相同
2.方法的参数个数或类型必须不相同
3.方法的返回类型可以相同或则不相同
4.方法名称相同的时候，编译器会根据调用方法的参数个数，参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译报错

7.方法的可变参数

三个点，

8.画板的操作

mspaint     在cmd进行操作

9.递归

递归的两部分:
递归头:什么时候不调用自身方法。如果没有头，将陷入死循环。
递归体:什么时候需要调用自身的方法。

10.for 增强型

for加强只能实现全部信息输出，不会实现个别的输出.

package KuangStudy;
public class JiuJiu {
    public static void main(String[] args) {
        int []arrays={1,2,3,4,5};
        for(int array :arrays){     //前面的是变量，后面是数组
            System.out.println(array);
        }
    }
}

11.面向对象的编程

面向对象的本质就是:

以类的方式组装代码，以对象的组织(封装数据)

封装: 钱包
继承: 遗产
多态:面貌
从认识论角度来说:现有对象后又类，对像是具体的事物。类是抽象的，
是对对象的抽象.
从代码运行的角度来说:先有类后有对象。

构造方法:当我们创建一个对象的时候，就会默认调用依次构造函数
无参构造:当写无参的时候，可以不用写有参
有参构造:当写有参的时候，必须要写无参

封装:
我们程序应该追求 高内聚低耦合，高内聚就是类的内部数据操作细节自己完成，
不允许外部干涉。低耦合、；劲爆露少量的方法给外部使用，
数据的隐藏:
通常,应禁止直接访问一个对象中的数据的实际表示，而应该通过操作接口来访问，
这称为数据隐藏。
属性私有: private（属性）     public get/set(进行设置和获得)

继承:
继承的本质是对某一屁勒的抽象，从而实现对现实世界更好的建模
extend的意思是"扩展".子类是父类的扩展
java 中类只有单继承，没有多继承
类与类之间的一种关系:除此之外，类和类之间的关系还有 以来，组合，聚合等

 ctrl+h  打开族谱（object 祖宗类）
 
super注意点:
1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或则构造方法中，
3.super和this不能同时调用构造方法!
this
代表的对项不同
this:本身调用者的这个对象
super:戴白哦父类对象的应用
前提
this:没有继承也可以使用
super：只能继承条件才能使用
构造方法:
this() 本类的构造方法
super() 父类的构造；



（多态的关键）父类的引用可以指向子类
eg:
父类public class B{}
子类public class A  extends B()(){}
在测试类中:
A a=new A();
父类的引用指向了子类
B b=new A();

多态:
即同一方法可以根据发送对象的不同而采用不同的行为方式.
即一个对象的实际类型是确定的，但可以指向对象的引用类型有很多.
实际类型  new student() new person().
引用类型 student stu=new student(); person per=new student();

多态注意事项:
1.多态是方法的多态，属性没有多态.
2.父类和子类必须要有联系。 
3.存在条件:继承关系，方法需要重写，父类引用指向子类对象。
多态存在的条件:
1.有继承关系(extends)
2.子类重写父类的方法()
3.父类引用指向子类对象

（对象能执行哪些方法，主要看对象左边的类型，和右边的关系不大，也就是说只看
等号左边的。）

父类不能直接调用子类的方法，如果想调用子类的方法，那么我们需要（高转低）强制转换
（和数据类型的强制转化的模式一样）。

多态EG :
1.
package KuangStudy;
public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        //引用类型指向子类
        Person person = new Student();
        Object object=new Student();
       //引用类型调用父类
        person.run();   //调用的是person父类中的函数
        //进行重载
        person.run(); //子类重写了父类，执行子类的方法
        student.run();
    }
}
2.
package KuangStudy;
public class Person {
    public void run(){
        System.out.println("人类");
    }
}

3.
package KuangStudy;
public class Student extends Person{
public void run(){
    System.out.println("学生");
}
public void Kill(){
    System.out.println("kill");
}
}

重载与重写:
重写:需要有继承的关系，子类重写父类的方法！（static.finnal.private不可被
重写）
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大: public>protected>default>private
4.抛出的异常: 范围可以被缩小，但不能被扩大(损失)
5.子类的方法和父类必须一致，只不过是里面的方法体不同
eg：
Panel 类中的方法
public void paint(){}    这里是什么 下面也是什么
如果我们对其重写的话:
public void paint(){}    、
=================================================================
重载:
1.方法的名字必须相同
2.方法的参数个数或类型必须不相同
3.方法的返回类型可以相同或则不相同
4.方法名称相同的时候，编译器会根据调用方法的参数个数，参数类型等去
逐个匹配，以选择对应的方法，如果匹配失败，则编译报错

===================================================================
静态方法（）和非静态方法
因为静态方法是类的方法，而非静态是对象的方法
有static时，b调用了b类的方法，因为b是b类定义的
没有static时，b调用的是对象的方法，而b是用A类的new的
即b是A new出来的对象，因此调用了A的方法
static 最先执行

12.内部类

定义:
在一个类中，继续写一个类。那么这个类就叫做内部类.
外部类的调用内部类的方法:
【内部类所在类的类名.内部类对象】 对象名=【内部类所在类的对象名.new 内部类名();

13.异常处理

 1.检查时异常     （检索时发现 ）
 2.运行时异常   （能运行，但有错）
 3.错误异常error    （栈溢出，等等）
try  (尝试)
catch (捕获异常)-------Throwable(最大) ---error-----expection----
finally(最后执行)