【Java笔记】Week02 -- JavaSE基础语法、OOP基础知识

写在前面的部分

本周主要学习了Java三大流程控制中的条件控制和循环控制，数组和方法的使用，还有面向对象(OOP)部分的基础知识。

Java基础语法 - 流程控制

1.顺序控制（依次执行代码）

2.条件控制

a. 目的 ： 对程序执行，一些不可预知的流程，进行一个预先判断.

b. 条件:

条件具有真假的特性。而且只可能为真，或者为假。

（1）可以是一个表达式

  第一类表达式: 常量表达式 -- 2*2,6-5

  第二类表达式: 包含变量的表达式 -- score > 90

（2）boolean类型 

表达式需要最终输出boolean类型

c.实现的四种方式

（1） if...

if(条件) {//实现的代码}

（2） if...else...

if (条件) {//实现的代码}else {//}

（3）if ...else if ...else

if (条件) {//}else if {//}else {//}

对于这种格式的条件控制语句，最多不要超过三层

应用举例

if (score > 0 && score < 60) {System.out.println("E");}else if (score < 70) {System.out.println("D");}else if (score < 80) {System.out.println("C");}else if (score < 90) {System.out.println("B");}else if (score <= 100) {System.out.println("A");}else {System.out.println("Error Data");}

(4)  switch...case

switch(判断值){
case 值1:
break;
case 值2:
break;
//.......
case 值n:
break;
default:
}

注意:

1. switch 后面的 () 一定不能省略

2. switch 后面跟的是整型或者是字符型

实际上，对于char型来说，在这里也是先转换成ascII码，然后进行比较的

3. case 值, 只能是字面常量(1,2, 'A','c'); 常量表达式( 2 * 3, 'a'+3)

4. break; 跳出我们匹配到的条件。 break 可以省略的。

break可以跳出我们的switch代码块，如果省略掉switch. 那么代码将会在第一个匹配成功的条件，

一直向下继续执行我们的switch语句，直到遇到break为止.

5. default: 可以省略，而且default 可以放到任何的位置 

   default作用: 当匹配不到任何条件的时候，执行的内容.

应用举例

switch(turn){default:System.out.println("100");break;//下面的代码是简化后的代码

case 1:case 2:case 3:System.out.println("800");break;//如果多个case中的代码一致 可以进行如下的简化case 4:case 5:System.out.println("500");break;

条件控制语句来说：彼此可以嵌套使用.

3.循环控制

a. while...

特点：先判断后执行

while (循环条件) {//代码部分}

b. do...while...

特点：先执行后判断；不管条件是否成立，都会至少先执行一次do 中的代码

do {//代码部分}while(循环条件)

c.for(使用率最高)

for(循环变量初始化 ;循环条件判断; 循环变量的改变) {//代码部分}

(1) 这三个部分都可以省略，但是; 不可以省略
(2) 循环变量: 我们可以定义多个,对于循环变量的改变，我们也可以同时改变多组变量

//多个循环变量的情况//可以定义第二个变量记录循环的次数for(int i = 0,num = 0;i < 100;i+=4,num++){  System.out.println("i:" + i);System.out.println("num:" + num);}

(3)执行流程:

(a).循环变量初始化，这个在整个的循环过程中，只会执行一次

(b).进行循环条件的判断，如果满足条件，则执行，否则结束循环

(c).当循环条件满足之后，并且执行了我们循环中定义的代码，最后就会进行循环变量的改变。

d. foreach 循环(不是一个常规的java提供的循环的方式，他只是java提供的一种语法糖)

foreach: 对一种循环方式的命名，常规循环的简化方式. 

语法糖： 针对基本的语法，提供了一种简化的实现方式.

e. 循环的嵌套

应用举例：* 的输出

输出格式：

*

**

***

****

*****

for(int j = 1;j<=5;j++){for(int i =1;i<=j;i++){System.out.print("*");}System.out.println("");}

5.continue,break

a. continue:

在循环的代码体中，如果遇到continue, 则会跳出当次循环，循环体内continue之后的代码都不会执行，并且循环变量进行一次改变操作，

之后再次进行条件判断，如果满足条件，则进入循环，否则直接结束循环; 跳出的仅是continue外层直接包裹的循环.

b. break:

在循环的代码体中，如果遇到break,则会跳出本循环代码块，break后的代码不会执行。并且整个循环的过程结束。

break后退出的循环也是直接包围break的循环。

数组的应用

1.数组的定义：

用来一次性保存多个相同类型元素的这样一种数据结构.

2.维度：

一维数组，多维数组.

3.数组的声明：

a. 类型[] 数组名;

int[] arr;

b. 类型 数组名[];

int arr[];

4.数组的初始化

a. 动态初始化

我们在定义一个数组和对数组进行赋值的操作，我们分开来执行。

int[] arr = new int[3];arr[0] = 1;arr[1] = 2;arr[2] = 3;

b. 静态初始化

我们在定义一个数组的同时，进行数组的初始化

int[] arr = {1,2,3,4};int[] arr1 = new int[]{1,2,3};

5.length

表示数组元素的个数

应用举例

int a[] = new int[]{1,2,3};int size = a.length//长度为3

6.数组的访问

arr[index]: index表示数组元素的索引，注意索引是从0到length-1.
arr[1]:访问第二个元素
index: 可以是常量，也可以是表达式。

7.简单应用

定义一个保存10个整型元素的一维数组，其中值为1到10,我们分别求 这十个数的和，以及十个数的平均值，
以及俩俩相邻的差，最终的和。

int num[] = new int[10];int sum = 0;int sum2 = 0;double avg;for (int i = 0;i < 10;i++) {num[i] = i + 1;sum+=num[i];}avg = (double)(sum)/num.length;for  (int i = 0;i < 9; i++) {sum2+=num[i + 1] - num[i];System.out.println(num[i+1] + " - " + num[i] + " = " + (num[i+1] - num[i] ));}System.out.println("和为：" + sum);System.out.println("平均值为：" + avg);System.out.println("差的和为" + sum2);

8.二维数组

a. 声明:
类型[][] 数组名称;

int[][] arr;

b. 初始化

(1) 动态初始化

int[][] arr = new int[3][];

(2) 静态初始化

int[][] arr = {{1,2,3},{2,3,4,5}};

Java中的方法

1.定义

实现一个功能的代码片段的封装。

[修饰符...] 返回值类型 方法名称(形参的列表){
//方法中实现的逻辑
}

public static void main(String[] args) {//}

2.形参列表

方法接收外部传入的数据的接收媒介.

3.返回值

方法执行结束之后，返回的值的类型。
如果方法不需要返回任何的值，那么我们的方法返回类型写作void.
在方法里返回一个值，需要用到 return. 

4.唯一确定一个方法的几点

a.方法名是否一致
b.形参列表的所有参数类型和数量是否一致。 对于形参变量的命名，完全是没有关系的.
c.返回值的类型 可以是基本类型，也可以是引用类型。

5.方法的应用

根据一周中的日期确定每天要读的书

package org.westos;import java.util.Scanner;public class MethodDemo {//private static String getBook(int date) {switch(date) {case 1: return "Chinese";case 2:return "Math";case 3:return "Physics";case 4:case 5:return "Chemistry";case 6:case 7:return "Java";default:return "Error Date!";}}//public static void main(String[] args) {int date;System.out.print("Please input the date:");Scanner sc = new Scanner(System.in);date = sc.nextInt();System.out.println(getBook(date));}}

OOP基础知识

1.类

a.定义

类: 是封装对象的属性和行为的载体。具有相同属性和行为的一类实体，可以称为类

[修饰符] class 类名 {

//代码部分

}

b.类由两部分组成

(1)成员变量

修饰符…] type name [=默认值]

(2)方法

c.类之间的关系

(1)关联关系(最弱)

(2)继承关系(一个子类只能有一个父类)

(3)聚合(关系聚集和组合)

d.简单应用

定义一个类，类中有2个成员变量，再分别定义俩个方法，这俩个方法的作用是给成员变量赋值.

package org.westos;public class OopDemo {int num;double num1;public void assignPar(int a) {num = a;}public void assignPar(double a) {num1 = a;}public static void main(String[] args) {OopDemo o = new OopDemo();o.assignPar(1);o.assignPar(1.8);System.out.println("num =" + o.num + " num1 = " + o.num1);}}

变量的作用域

1.变量的分类

a.成员变量:

类的属性

b.局部变量:

方法中定义的变量或者是方法的形式参数。

2.块

a.作用域控制是通过块来控制的.

b.块的概念:

一对{} 包裹，该代码片段就称为 一块.

3.作用域控制

a.对于当前的块，不能再定义同名的变量,即使类型不同也不行。
b.对于当前的块，定义了某个变量，在块外不能够访问到块中定义的变量
c.如果存在块的嵌套:
那么外层块定义的变量，在内层块中是可以访问到的.

构造方法 -- 构造器

1.定义

类中特殊的方法，它的方法名必须和类名一模一样，并且不返回任何的值，主要不能添加void.

类名(形参列表) {

//代码部分

}

2.默认构造器

在我们new一个类的对象时,会先调用类的构造器,如果我们没有写构造器,编译器会帮我们添加一个默认的构造器

类名() {

}

3.含参列表的构造器

含参数列表的构造器可以通过接收传来的参数给成员变量进行初始化或者其他操作.

package org.westos;public class Person {int age;double height;double weight;boolean  isMale;//下面的含参数列表的构造器,作用是给成员变量初始化Person(int age,double height,double weight,boolean isMale) {this.age = age;this.height = height;this.weight = weight;this.isMale = isMale;}public String getSex() {if(isMale) {return "男孩";}else {return "女孩";}}public static void main(String[] args) {Person person = new Person(18,79.2,80,true);//调用构造器构造对象System.out.println(person.getSex());}}

调用构造器构造对象时注意参数与构造器的数量类型俊一致

注意:

主动添加含参数列表的构造器后,若未添加默认构造器,则再进行new 类名()的操作时,编译会报错

方法重载

1.定义

同名但参数列表不同的方法

int sum(int[] num) {//对数组元素求和}int sum(int a.int b) {//对两个数求和}

注意:仅仅返回值类型不同的方法不叫重载

2.简单应用

定义一个类，类中有个1维数组的成员变量(short)。 提供俩个方法，第一个方法接受一个int数组，第二个方法接受一个long型的数组。

两个方法均将各自 形参传入的数组中元素的值进行求和。 并且与本身我们类成员变量数组的和做一个差。 最终返回这样的结果。

package org.westos;public class OverloadDemo {short[] arr = new short[]{1,2,3,4,5};//对int数组求和int arrSum(int[] arr){int sum = 0;for(int i = 0; i < arr.length; i++) {sum += arr[i];}return sum;}//对long数组求和long arrSum(long[] arr){long sum = 0;for(int i = 0; i < arr.length; i++) {sum += arr[i];}return sum;}//对short数组求和short arrSum(short[] arr){short sum = 0;for(int i = 0; i < arr.length; i++) {sum += arr[i];}return sum;}//求int 与 short 的差int function(int[] arrInt){int sum = arrSum(arrInt);short sum1 = arrSum(arr);return sum - sum1;}//求 long 与 short 的 差private long function(long[] arrLong){long sum = arrSum(arrLong);short sum1 = arrSum(arr);return sum - sum1;}public static void main(String[] args) {long[] arrLong = new long[]{5L,2L,7L};int[] arrInt = {3,4,5,76};System.out.println();System.out.println();}}

类的继承

1.定义

class A extends B {//代码部分}

A类继承B类

2.注意

子类可以享有父类的方法。在初始化一个子类对象的时候，调用其中的方法，如果该方法中在父类也有定义，并且参数列表不同，则调用到的是子类特有的方法。否则调用的是父类方法。

3.简单应用

定义一个Animal类和Bird类

package org.westos;public class Animal {int age;String kind;String[] favFood;void eat() {System.out.println("Eat!");}void spark() {System.out.println("spark!");}public static void main(String[] args) {Bird b = new Bird();Animal a = new Animal();a.eat();b.eat();b.fly();}}class Bird extends Animal {String NickName;void eat() {System.out.println("Bird eats！");}void fly() {System.out.println("Bird flies!");}}