JAVASE初级笔记

  第一步：新建一个文本文档，文件名为Hello

  第二步：修改文件后缀名为 .java

  第三步：在Hello.java文件中，写入这样一段代码：

public class Hello{       public static void main(String args[]){            System.out.println("作人没有梦想，那跟咸鱼有什么分别");       } }

 

 

 

 

 

 

  注意：代码中的中括号大括号分号等，都必须是英文字符

  第四步：打开一个DOS窗口，使用javac命令编译java源文件

  注意：使用javac命令的前提是要正确的配置path环境变量

  第五步：确保生成Hello.class文件，使用java命令运行字节码文件

if(a[i] > a[j]) {        int t = 0 ;     t = a[i];     a[i] = a[j];      a[j] = t; }大括号内的语句都属于if语句块

 

 

  几款代码编辑工具

  UltraEdit、Notepad++、EditPlus

 

  变量：intx=4;

n 局部变量：

u 定义在方法内的变量，或语句块内的变量

u 局部变量必须赋初始值，不然没法使用。

n 成员变量：

u 定义在类里面，方法的外面，属于对象，每一个对象拥有本身的成员变量，互相不冲突

u 成员变量未初始化时，系统会自动初始化，给默认值。

n 静态变量：（也叫类变量）

u 定义在类里面，方法的外面，static关键字修饰。属于类，全部对象共享一个变量

n 常量: final int y = 6;

  JAVA的命名规范：

n 不可跟关键字重复

n 只能包含数字、字母、下划线、$，其中数字不能够开头

  关键字：

  数据类型：

 

 

 

 

 

 

 

 

n 分为两大类：基本数据类型和引用数据类型

n 引用类型的变量也叫指针，它保存了一个对象的内存地址

n Student  stu =  new Student（）;

stu 就是引用变量，把一个对象赋给stu，也就意味着stu此刻保存了对象的地址。咱们能够经过stu来调用这个对象的方法，或者访问对象的属性。 注意引用变量也是有类型区分的，stu 的类型是Student,所以有时咱们会说stu这个对象是Student类型的。

 

 

 

 

 

 

 

 

  基本数据类

n Int 整数型 4字节

n Short 短整型 2

n Byte 字节型 1

n Long 长整型 8

n Float 单精度浮点型 4

n Double 双精度浮点型 8

n Char 字符型 2

n Boolean布尔型 1

  类型转换

u char型、short型、byte型运算时，只能转换为int型

u 自动转型(类型的自动提高)的原则范围由小到大、精度由低到高

u int a =4, b=5;

u (float) (a*b) 注意在类型转换时，运算的优先级：

u 若是写成了(float)a*b,则会先把a转成float类型再与b进行计算，那跟咱们想要的结果就不同了，所以这里要特别当心。

  转义字符： \反斜线加上字符

n \t         \n        \\         \”

  运算符：

n 算术运算符

u + 、-、*、/、% 取模 求余数

n 关系运算符

u >、<、==、!=、>=、<=、

n 一元运算符

u +、-、~、！

n 赋值运算符

u =

n 逻辑运算符

u &&、|| 、!

n 递增、递减运算符

u ++、--

n  三目运算符

u (布尔表达式) ？ 表达式1 ： 表达式2

u 布尔表达式的值为真时，运算结果为表达式1，不然结果为表达式2

u 例1： (a == 30)  ?  x +=5 : x = 0;

l 若是a等于30，则执行x+=5，不然执行x=0;

u 例2：String str = (a == 30)  ?  “哈哈” : “呵呵” ;

l 若是a等于30，str的值是 哈哈，不然 呵呵

  运算符的优先级关系

 

  if语句的使用

n  If语句接受一个逻辑表达式，判断真假

if(a>30) {     System.out.println("aaaa"); } else if(a < 25){     //……… }

 

 

 

 

   

 

  switch语句

n  只能作等值的判断（==），而且只能判断int变量或能够转换成int型的变量

n  当心case穿透，记得要加break语句

n  注意理解if和switch的用法上的区别，理解它们的使用场合

 

char c = 'm'; switch(c) {     case 'x' : { System.out.println("x"); System.out.println("x"); break; }     case 'm' : System.out.println("m"); break;     case 'z' : System.out.println("z"); break;     default : System.out.println("默认状况"); }

 

 

 

 

 

 

 

 

 

  While循环

int i = 0; while(i<100/*循环条件*/) {     System.out.println("循环第"+i+"次");     i++; }

 

 

 

 

 

dowhile循环：第一次执行循环体，不判断条件！

  For循环

n  99乘法表

u 

for (int i=0; i<=10; i++){       System.out.println(i); } //打印出i的值，观察结果

第一步：创建一个for循环

u  


 

u 

for (int i=0; i<=10; i++){       for(int j=0; j<=10; j++){            System.out.println( i );            System.out.println( j ); } }//打印出i的值，观察结果, 打印j的值观察结果

第二步：创建循环嵌套

u  




 

u 

for (int i=0;i<=10;i++){       for(int j=0; j<=i; j++){            System.out.println( i );            System.out.println( j ); } }//再观察结果 //打印出i的值，观察结果

第三步：修改子循环的循环条件，让子循环的次数变成动态值

u  





 

  break语句和continue语句

n  break： 终止当前循环体，或switch 语句块

n  continue：终止本次循环，直接进入下一次循环

  DEBUG跟踪调试程序

n  第一步设置断点

n  第二步以DEBUG模式来运行程序

 

int[] a = {23, 99, 8, 10}; int[] b = a;

数组的内存结构

 

堆内存

0

1

2

3

23

99

8

10

栈内存

a #9852

b #9852

注意！数组的下标从0开始

数组里存放的整型数

 

 

 

 

 

 

 

 

 

 

 

 

  数组  若干相同类型的数据的集合

n  double[]  arr = new double[5];

n  double[]arr = {2,6,3,7,8};

n  double[]arr = new double[]{2,6,3,7,8};

n  arr.length得到数组的长度

n  数组的下标从0开始  因此arr[2] 表明数组的第三个元素

  二维数组 一个存放数组的 一维数组

n  int[][]arr = new int[5][5];

arr[0]= new int[5];[A1] 

n  int[][] arr2  =  { {1,2,3}, {2,4,5},  {5,6,7},  {1},  {4,4,4,4}};

n  arr2[0] 表明第一个子数组   也就是 {1,2,3}

n  因此要访问子数组的第三个元素，应该：arr2[0][A2] [2]

堆内存

0

1

2

3

栈内存

arr

1

2

3

2

4

5

arr[0]

arr[1]

arr[2]

arr[3]

 

 

 

 

 

 

 

 

 

 

 

  多维数组

n  int[][][][]  arr = new int[5][4][3][2];

  冒泡排序、选择排序法、快速排序

n  数组元素的交换  有元素a、b、

u  首先定义一个临时的变量temp

u  temp= a;
a = b;
b = temp;

  加强for循环（for-each）

Product[]  plist = {new Product(), new Product(), new Product()}; for( Product  p  :  plist) {        p.toString(); } //加强for循环写起来很简便，但也有缺点，因为它不像for循环有循环变量，所以咱们没法经过下标去访问数组，可是，对于上面这个加强for 循环来说，操做对象p，一样能够改变数组里面的对象的属性，这是为何呢？

 

 

 

 

 

 

 

  面向对象的基本思想

n  从传统的面向过程发展而来的。

n  面向过程的思惟：

u  第一步买菜，第二步洗菜，第三步切菜，第四步炒菜

n  面向对象的思惟：

u 

对象

第一步采购员 完成本职工做

u  第二步帮厨     完成本职工做

u  第三步案板      完成本职工做

u  第四步大厨     完成本职工做

n  把不一样的工做交给不一样的角色（对象）来处理，每一个对象负责本身的工做。这个过程当中还体现出了封装的概念！

n  类和对象

u  类就是一个模板，或者能够看作是咱们本身定义的数据类型

u  对象就是利用模板建立的一个具体事物，或者能够看作是使用自定义数据类型声明出来的变量，在JAVA中咱们把对象叫作一个类的实例

n  如何定义一个类？

public  class  Product {        public  static  int  num = 10; }

 

 

 

 

 

l  成员变量： 普通的成员变量和静态成员变量（类变量）

n  类变量是全部对象共享的，能够经过类名直接访问：

n  Product.num 而不须要构造对象

l  如何建立一个对象

n  类名  对象名 = new 类名（）；

n  Product  p1 = new Product();

l  Product()被称之为构造方法，它是一个很特殊的方法：

n  构造方法名必须和类名相同

n  构造方法不能够写返回值类型

n  构造方法默认状况下不须要显示的去声明，系统帮咱们默认建立

n  调用构造方法必需要跟new关键字配合

n  系统默认建立的构造方法是无参的

n  一旦咱们定义了任何一个构造方法，系统默认的会自动失效

n  构造方法能够同时定义多个：在JAVA中，同一个类里，多个方法名称相同，为了区别，要求参数不能同样，这种形式叫作方法重载

l  类的继承

public  class  Product  extends  Object{        public  static  int  num = 10; }

 

 

 

 

n  继承的最大做用是可以让子类拥有父类的方法和属性，全部子类都遵循父类的特性，而且在父类的方法不能知足需求的时候，咱们能够经过重写覆盖父类的属性和方法。

n  同时，继承在某种程度上说，也是一种分类的方式，咱们说类是一种模板，经过类来构造对象。那么模板也是有分类的。

n  例如：动物类能够分为：无脊椎动物和脊椎动物
其中脊椎动物又分为鱼类、两栖类、爬行类、鸟类、哺乳类等。
有了继承，分类能够更加明细，更加清晰

n  [A3] 子类继承父类的属性和方法

u  静态属性是不继承的

u  私有属性子类不可以直接访问

u  JAVA当中只有单继承

u  建立子类对象的时候，在调用子类构造方法的时候，会先调用父类的构造方法

u  若是父类还有父类，会从最顶层的父类构造方法开始调用，一直到子类的构造方法

n  子类继承父类的属性和方法，均可以本身重写，重写以后，覆盖父类的方法，这个叫作方法的重写

n  权限修饰符：private  public protected  默认(什么都不写)

修饰符	同一个类	同一个包	子类	不一样包
Public	√	√	√	√
Protected	√	√	√
默认	√	√
Private	√

n  类的封装

u  将某些属性或方法设为私有的，防止外界直接访问
提供一个公有的方法，让外界经过公有方法间接访问

u  封装的主要目的其实在于隐藏，隐藏没必要要的细节过程。例如一台电脑，内部结构异常的复杂，生产厂商将内部的细节封装起来，咱们只能经过鼠标和键盘来操做电脑，这样的好处在于，咱们没必要了解其内部的复杂构造，而只须要键盘简单的操做就可使用电脑。

u  再好比一台汽车，咱们操做一台车只能经过油门、刹车、方向盘。其余的细节内容都被封装了起来，发动机内部到底作了什么事情，咱们没法得知，固然咱们也不肯意去关心那些细节问题，咱们只须要会使用油门和方向盘就足够了，这不正是封装带来的好处么？

n  [A4] super、this分别表明：

u  super表明了父类对象的引用

u  this表明了当前对象的引用

n  static关键字

u  用static修饰的变量和方法，叫作静态变量或静态方法，从属于类，能够经过类名直接调用。

n  package关键字

n  import关键字

n  final关键字

u  修饰变量：变量的值不能够改变！而且必须在定义的时候赋初值

u  修饰方法：这个方法将不可以被子类重写

u  修饰类：该类将不可以被继承

l  类的多态：能够理解为多样性，或多种表现状态

n  方法的重载也算是多态的一种表现形式

n  方法的重写一样能够表现出多态的特性

n  举例：

      父类   ss =  new 子类();

子类被转型成父类，因为父类的层次比子类高，所以这里能够进行自动转型。无需手动干预。

转型以后，ss为父类的引用，此时ss只能调用父类的方法，子类特有的方法，ss无权调用。

只有一种特殊状况可使用子类的方法，就是父类中的方法被子类重写，此时父类方法被覆盖，就能够调用子类方法。

举例：

 

public class Animal {     public int attack = 100;//攻击力         public void sound() {//声音        System.out.println("Animal sound");     } }

 

 

 

 

     

     

有父类Animal，包含一个方法名称为sound

子类重写父类的sound方法

public class Cat extends Animal {     @Override     public void sound() {        System.out.println("喵喵");     }     public void catchMouse() {        System.out.println("抓老鼠");     } }

 

 

 

 

 

 

 

 

此时如有父类引用指向了一个子类对象cat

Animal  animal =  new  Cat();

父类引用调用sound方法，执行的仍然是子类对象的sound方法

   这时，sound方法所表现出来的结果，是多种多样的，根据子类的不一样，获得的结果也不一样。一样都是sound 方法，却有多种结果能够出现。咱们将这种情形称之为多态。

   因此说重载、重写都是多态的表现，也就是说方法名称相同，但具体操做不一样。好比咱们说“吃”这个字，在不一样的状况下咱们能够有多种含义，例如：吃饭、吃钉子、吃官司等，具备相同的名称，但具体的操做却不同。再好比“开”这个字，开车、开窗、开饭、开局等等。

了解更多详情请登陆超人学院网站http://www.crxy.cn或者每周日晚八点半相约免费公开课 https://ke.qq.com/course/53102#term_id=100145289  具体详情请联系QQ2435014406