java学习基础

• 1.带标签的break和continue

                continue outer

• 2.实参，形参

                1.实参：调用方法时实际传给方法的数据

                2.形参：在方法声明时用于接收外界传入的数据

• 3.重载（overload）

                不同的方法，名字相同，形参类型，形参个数，形参顺序不同

                    方法如果用static修饰可以直接调用，不用创建对象

public class ChengFa {

    public static void main(String[] args) {

//        add(1,2);不能直接调用

        //先创建对象

        ChengFa chengFa=new ChengFa();

        int add1 = chengFa.add(1, 2);

        System.out.println(add1);

//        方法如果用static修饰可以直接调用

        int add2 = add(1, 2, 3);

        System.out.println(add2);

    }

        int add(int a,int b){

        return a+b;

    }

    public static  int add(int a,int b,int c){

        return a+b+c;

    }

}

• 4.递归，自己调用自己

递归会占用大量的系统堆栈

使用递归能解决的问题，也可以使用循环来解决

递归很花费时间，耗内存

    public static void main(String[] args) {

//        递归求阶乘

        int i = jieCheng(5);

        System.out.println(i);

    }

    static int jieCheng(int a){

        if (a==1){

            return 1;

        }else {

           return a*jieCheng(a-1);

        }

    }

                

• 5.变量：可操作的存储空间

• 6.面向过程和面向对象的区别

C：面向过程 （怎么按照步骤一步一步实现，适合简单的任务：不需要协作的任务：一个人 如何开车）

C++，Java：面向对象  （需要协作 如何造车？  适合开发大型软件）

面向过程和面向对象的总结：

1.都是解决问题的思维模式，都是代码的组织方式

2.解决简单问题使用面向过程

3.解决复杂问题采用面向对象，宏观上使用面向对象的把握，微观处理仍然是面向过程。

• 7.对象和类

内存里的内存块，包含了很多数据

学生是一个对象，这个对象里面有属性（age，sex，name）和方法（getname，getage）。

类：class   对对象的抽象

对象：object，instance，某个类的对象，某个类的实例

• 8.局部变量，成员变量

局部变量：方法体中，形参

成员变量：方法外，类中

• 9.典型类的写法和调用类的方法

//一个java文件可以有多个类，但只能有一个public修饰的类

public class Student {

    int age;

    String name;

    Computer1 comp;

    void play(){

        System.out.println("play"+comp.brands);

    }

    public static void main(String[] args) {

        Student student=new Student();

        student.name="ert";

        student.age=12;

        Computer1 computer2=new Computer1();

        computer2.brands="wert";

        student.comp=computer2;

        student.play();

    }

}

class Computer1{

    String brands;

}

• 10.内存分析，详解栈堆内存变化过程 p64

java虚拟机的内存分为三个部分：栈（stack），堆（heap），方法区（methods area）

栈： 1、描述方法执行的内存模型，每个方法被调用都会创建一个栈帧（存储局部变量、操作数、方法出口）

        2、jvm为每个线程创建一个栈，存放该线程执行方法的信息。

        3、栈是线程私有的，不能共享

        4、栈是系统自动分配的，速度快，连续的内存空间。

堆： 1、存放创建好的对象和数组new 

        2、jvm只有一个堆，被所有线程共享

        3、不连续的内存空间，分配灵活，慢。

方法区（静态区）：

        1、一个方法区，被所有线程共享

        2、也是堆，存放类、常量相关信息

        3、存放永远不变或者唯一的内容（类信息，静态变量，字符串常量。）

• 11. this 指本对象，静态方法中不能使用this

 this.a =a  

构造方法用this替代

 this（a,b）//在一个构造方法中引用另一个构造方法

• 12. static  

静态方法里面不能调用非静态方法和非静态属性，因为静态方法，静态变量存放在堆的方法区，而堆中存放对象，栈存放主函数

• 13. 构造方法用于对象的初始化，静态方法用于类的初始化，所有两个都存在，先类的初始化，再对象的初始化。

静态方法的初始化：static{

                            }

• 14.覆盖重写

• 15.继承：单继承  多实现

• 16.引用传参

• 

  

• 17. 重写equals方法   

string ：==false   .equals  true    

对象   ：==false .equals false

• 18. 构造方法首先有一个默认super

• 19. final  

方法＋final 不能重写  

父类＋final  不能继承    

变量＋final  常亮，不能修改

• 20.多态

多态是方法的多态，不是属性的多态

有三个多态必要条件：继承，方法重写，父类引用指向子类对象

public class Duotai {

    public void sbrest(Person person){

        person.rest();

    }

    public static void main(String[] args) {

        Person student1=new Student1();

        Duotai duotai=new Duotai();

        duotai.sbrest(student1);

    }

}

class Person{

    String name;

    int age;

    public void rest(){

        System.out.println("休息一下");

    }

}

class Student1 extends  Person{

    public void rest(){

        System.out.println("学生休息一下");

    }

}

class  Teacher1{

    public void rest(){

        System.out.println("老师休息一下");

    }

}

• 21.private，protecred，public

一般使用private修饰属性，使用相关get、set方法来访问相关属性，方法通常用public修饰

• 22.abstract  extends

有抽象方法的一定是抽象类。抽象类不一定有抽象方法。

父类定义抽象方法，但不会实现，子类必须实现抽象方法。

抽象类不能实例化，不能new一个抽象类，只能被继承。

抽象类里面可以有一些普通方法

• 23.接口 多继承 （比抽象类还要抽象） extends（父接口） implements   interface

接口中，只有抽象方法和属性，属性是常量 （public abstract） void test（）；规范和具体实现分离。