Java基础从0开始02

2.1_Java语言基础(循环结构概述和for语句的格式及其使用)

A:循环结构的分类
for,while,do…while

B:循环结构for语句的格式：

for(初始化表达式;条件表达式;循环后的操作表达式) {
    循环体;
}

C执行流程：
a:执行初始化语句
b:执行判断条件语句,看其返回值是true还是false
如果是true，就继续执行
如果是false，就结束循环
c:执行循环体语句;
d:执行循环后的操作表达式
e:回到B继续。

class  demo
{
    public static void main(String[] args) {
        for(int i=0;i<10;i++){
            System.out.println(i);
        }
    }
}

2.2_Java语言基础(循环结构while语句的格式和基本使用)

A:循环结构while语句的格式：
while循环的基本格式：

while(判断条件语句) {
    循环体语句;
}

完整格式：

初始化语句;
while(判断条件语句) {
     循环体语句;
     控制条件语句;
}
B:执行流程：

a:执行初始化语句
b:执行判断条件语句,看其返回值是true还是false
如果是true，就继续执行
如果是false，就结束循环
c:执行循环体语句;
d:执行控制条件语句
e:回到B继续。

class  demo
{
    public static void main(String[] args) {
        int i=0;
        while(i<10){
            i++;
            System.out.println(i);
        }
    }
}

2.3_Java语言基础(循环结构do…while语句的格式和基本使用)

A:循环结构do…while语句的格式：

do {
    循环体语句;
}while(判断条件语句);

完整格式：

初始化语句;
do {
    循环体语句;
    控制条件语句;
}while(判断条件语句);

B:执行流程：
a:执行初始化语句
b:执行循环体语句;
c:执行控制条件语句
d:执行判断条件语句,看其返回值是true还是false
如果是true，就继续执行
如果是false，就结束循环
e:回到b继续。

2.4_Java语言基础(循环结构三种循环语句的区别)

三种循环语句的区别:
do…while循环至少执行一次循环体。
而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。

for循环和while循环的区别：
A:如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。不知道用谁就用for循环。因为变量及早的从内存中
消失，可以提高内存的使用效率。

2.5_Java语言基础(控制跳转语句)

A:break的使用场景
只能在switch和循环中

B:continue的使用场景
只能在循环中

C:return的作用
返回
其实它的作用不是结束循环的，而是结束方法的。

D:案例演示
return是结束方法
break是跳出循环
continue是终止本次循环继续下次循环

2.6_Java语言基础(方法概述和格式说明)

A:为什么要有方法
提高代码的复用性

B:什么是方法
完成特定功能的代码块。

C:方法的格式

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
    方法体语句;
    return 返回值; 
} 

D:方法的格式说明
修饰符：目前就用 public static。后面我们再详细的讲解其他的修饰符。
返回值类型：就是功能结果的数据类型。
方法名：符合命名规则即可。方便我们的调用。
参数：
实际参数：就是实际参与运算的。
形式参数；就是方法定义上的，用于接收实际参数的。
参数类型：就是参数的数据类型
参数名：就是变量名
方法体语句：就是完成功能的代码。
return：结束方法的。
返回值：就是功能的结果，由return带给调用者。

class  demo
{
    public static void main(String[] args) {
            System.out.println(add(10,2));
    }
    public static int add(int a,int b){
            return a+b;
    }
}

2.7_Java语言基础(方法的注意事项)

A:方法调用(有具体返回值)
a:单独调用,一般来说没有意义，所以不推荐。
b:输出调用,但是不够好。因为我们可能需要针对结果进行进一步的操作。
c:赋值调用,推荐方案。

B:案例演示
a:方法不调用不执行
b:方法与方法是平级关系，不能嵌套定义
c:方法定义的时候参数之间用逗号隔开
d:方法调用的时候不用在传递数据类型
e:如果方法有明确的返回值，一定要有return带回一个值

2.8_Java语言基础(方法重载概述和基本使用)

A:方法重载概述
求和案例
2个整数
3个整数
4个整数
B:方法重载：

在同一个类中，方法名相同，参数列表不同。与返回值类型无关。

参数列表不同：

A:参数个数不同
B:参数类型不同
C:参数的顺序不同(算重载,但是在开发中不用)

class  demo
{
    public static void main(String[] args) {
            System.out.println(add(10,2));
            System.out.println(add(10,2,5));
    }
    public static int add(int a,int b){
            return a+b;
    }
    public static int add(int a,int b,int c){
            return a+b+c;
    }
}

2.9_Java语言基础(数组概述和定义格式说明)(了解)

A:为什么要有数组(容器)
为了存储同种数据类型的多个值
B:数组概念

数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。
C:数组定义格式 数据类型[] 数组名 = new 数据类型[数组的长度];

2.10_Java语言基础(数组的初始化动态初始化)(掌握)

A:什么是数组的初始化
就是为数组开辟连续的内存空间，并为每个数组元素赋予值

B:如何对数组进行初始化
a:动态初始化 只指定长度，由系统给出初始化值
int[] arr = new int[5];
b:静态初始化 给出初始化值，由系统决定长度

C:动态初始化的格式：
数据类型[] 数组名 = new 数据类型[数组长度];

D:静态初始化的格式：
格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
简化格式：
数据类型[] 数组名 = {元素1,元素2,…};

class  demo
{
    public static void main(String[] args) {
        int[] arr1 = new int[3];    //动态数组
        int[] arr2 = {4,5,6};       //静态数组
        for(int i=0;i<3;i++){
            arr1[i] = i;
            System.out.println(arr1[i]);
        }
        for(int i=0;i<3;i++){
            System.out.println(arr2[i]);
        }
    }
}

2.11_Java语言基础(Java中的内存分配以及栈和堆的区别)

A:栈(掌握)
存储局部变量

B:堆(掌握)
存储new出来的数组或对象

C:方法区
面向对象部分讲解

D:本地方法区
和系统相关

E:寄存器
给CPU使用

2.12_Java语言基础(数组操作的两个常见小问题越界和空指针)(掌握)

A:案例演示
a:ArrayIndexOutOfBoundsException:数组索引越界异常
原因：你访问了不存在的索引。
b:NullPointerException:空指针异常
原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。

int[] arr = {1,2,3};
arr = null;
System.out.println(arr[0]);

2.13_Java语言基础(数组的操作1遍历)(掌握)

数组遍历：就是依次输出数组中的每一个元素。
数组的属性:arr.length数组的长度
数组的最大索引:arr.length - 1;

public static void print(int[] arr) {
    for (int i = 0;i < arr.length ;i++ ) {
        System.out.print(arr[i] + " ");
    }
}

2.14_Java语言基础(数组的操作2获取最值)(掌握)

A:案例演示

数组获取最值(获取数组中的最大值最小值)

public static int getMax(int[] arr) {
    int max = arr[0];
    for (int i = 1;i < arr.length ;i++ ) {          //从数组的第二个元素开始遍历
        if (max < arr[i]) {                         //如果max记录的值小于的数组中的元素
            max = arr[i];                           //max记录住较大的
        }
    }
    return max;
}

B:案例演示

数组元素反转(就是把元素对调)

public static void reverseArray(int[] arr) {
    for (int i = 0;i < arr.length / 2 ; i++) {
        //arr[0]和arr[arr.length-1-0]交换
        //arr[1]和arr[arr.length-1-1]交换
        //arr[2]和arr[arr.lentth-1-2]
        //...

        int temp = arr[i];
        arr[i] = arr[arr.length-1-i];
        arr[arr.length-1-i] = temp;
    }
}

C:案例演示

数组查表法(根据键盘录入索引,查找对应星期)

public static char getWeek(int week) {
    char[] arr = {' ','一','二','三','四','五','六','日'};     //定义了一张星期表
    return arr[week];                                           //通过索引获取表中的元素
}

D:案例演示

数组元素查找(查找指定元素第一次在数组中出现的索引)

public static int getIndex(int[] arr,int value) {
    for (int i = 0;i < arr.length ;i++ ) {              //数组的遍历
        if (arr[i] == value) {                          //如果数组中的元素与查找的元素匹配
            return i;
        }
    }
    return -1;
} 

2.15_Java语言基础(二维数组概述和格式1的讲解)(了解)

A:二维数组概述
B:二维数组格式1
int[][] arr = new int[3][2];
C:二维数组格式1的解释
D:注意事项

a:以下格式也可以表示二维数组
1:数据类型 数组名[][] = new 数据类型[m][n];
2:数据类型[] 数组名[] = new 数据类型[m][n];
B:注意下面定义的区别

int x;
int y;
int x,y;

int[] x;
int[] y[];

int[] x,y[];    x是一维数组,y是二维数组

class  demo
{
    public static void main(String[] args) {
        int[] arr[] = {{1,2,3},{4,5,6},{7,8,9}};
        for(int i=0;i<3;i++)
            for(int j=0;j<3;j++){
                System.out.println(arr[i][j]);
        }
    }
}

2.16_Java语言基础(思考题Java中的参数传递问题及图解)(掌握)

class  demo
{
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("a:"+a+",b:"+b);
        change(a,b);
        System.out.println("a:"+a+",b:"+b);

        int[] arr = {1,2,3,4,5};
        change(arr);
        System.out.println(arr[1]);
    }

    public static void change(int a,int b) {
        System.out.println("a:"+a+",b:"+b);
        a = b;
        b = a + b;
        System.out.println("a:"+a+",b:"+b);
    }

    public static void change(int[] arr) {
        for(int x=0; x<arr.length; x++) {
            if(arr[x]%2==0) {
                arr[x]*=2;
            }
        }
    }
}

2.17_面向对象(面向对象思想概述)(了解)

A:面向对象思想特点
a:是一种更符合我们思想习惯的思想
b:可以将复杂的事情简单化
c:将我们从执行者变成了指挥者
角色发生了转换

B:面向对象开发
就是不断的创建对象，使用对象，指挥对象做事情。

C:面向对象设计
其实就是在管理和维护对象之间的关系。

D:面向对象特征
封装(encapsulation)
继承(inheritance)
多态(polymorphism)

2.18_面向对象(类与对象概述)(掌握)

A:我们学习编程是为了什么
为了把我们日常生活中实物用学习语言描述出来
B:我们如何描述现实世界事物
属性 就是该事物的描述信息(事物身上的名词)
行为 就是该事物能够做什么(事物身上的动词)
C:Java中最基本的单位是类,Java中用class描述事物也是如此
成员变量 就是事物的属性
成员方法 就是事物的行为
D:定义类其实就是定义类的成员(成员变量和成员方法)
a:成员变量 和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
b:成员方法 和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
E:类和对象的概念
a:类：是一组相关的属性和行为的集合
b:对象：是该类事物的具体体现
c:举例：
类 学生
对象 具体的某个学生就是一个对象

2.19_面向对象(类的定义)(掌握)

学生类的定义:
A:学生事物
B:学生类
C:案例演示
属性:姓名,年龄,性别
行为:学习,睡觉

手机类的定义:
模仿学生类，让学生自己完成
属性:品牌(brand)价格(price)
行为:打电话(call),发信息(sendMessage)玩游戏(playGame)

学生类的使用:
A:文件名问题
在一个java文件中写两个类：一个基本的类，一个测试类。
建议：文件名称和测试类名称一致。
B:如何使用对象?
创建对象并使用
格式：类名 对象名 = new 类名();
D:如何使用成员变量呢?
对象名.变量名
E:如何使用成员方法呢?
对象名.方法名(…)

class  demo
{
    public static void main(String[] args) {
    }
}
class student
{
    private String name;
    private int age;
    private String sex;
    public void study(){
            System.out.println("study");
    }
    public void sleep(){
            System.out.println("sleep");
    }
}
class phone
{
    private String brand;
    private int price;
    public void call(){
            System.out.println("call");
    }
    public void sendMessage(){
            System.out.println("sendMessage");
    }
    public void playGame(){
            System.out.println("playGame");
    }
}

2.20_面向对象(成员变量和局部变量的区别)(掌握)

• A:在类中的位置不同 ◦成员变量：在类中方法外
◦局部变量：在方法定义中或者方法声明上

• B:在内存中的位置不同 ◦成员变量：在堆内存(成员变量属于对象,对象进堆内存)
◦局部变量：在栈内存(局部变量属于方法,方法进栈内存)

• C:生命周期不同 ◦成员变量：随着对象的创建而存在，随着对象的消失而消失
◦局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

•D:初始化值不同
◦成员变量：有默认初始化值
◦局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。

•注意事项：
◦局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
◦基本数据类型变量包括哪些:byte,short,int,long,float,double,boolean,char
◦引用数据类型变量包括哪些:数组,类,接口,枚举

方法的参数是类名public void print(Student s){}//print(new Student()); ◦如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。

class  demo
{
    public static void main(String[] args) {
        student stu = new student();
        print(stu);
    }
    public static void print(student s){
        s.name = "jack";
        s.age = 21;
        s.sex = "man";
        s.message();
    }
}
class student
{
    public String name;
    public int age;
    public String sex;
    public void message(){
        System.out.println(name+"---"+age+"---"+sex);
    }
    public void study(){

            System.out.println("study");
    }
    public void sleep(){
            System.out.println("sleep");
    }
}

2.21_面向对象(匿名对象的概述和应用)(掌握)

• A:什么是匿名对象 ◦没有名字的对象

• B:匿名对象应用场景 ◦ a:调用方法，仅仅只调用一次的时候。 ◾ 那么，这种匿名调用有什么好处吗? ◾节省代码

◾注意：调用多次的时候，不适合。匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。

◦b:匿名对象可以作为实际参数传递

• C:案例演示 ◦匿名对象应用场景

class  demo
{
    public static void main(String[] args) {
        new student().study();
        print(new student());
    }
    public static void print(student s){
        s.name = "jack";
        s.age = 21;
        s.sex = "man";
        s.message();
    }
}
class student
{
    public String name;
    public int age;
    public String sex;
    public void message(){
        System.out.println(name+"---"+age+"---"+sex);
    }
    public void study(){

            System.out.println("study");
    }
    public void sleep(){
            System.out.println("sleep");
    }
}

2.22_面向对象(封装的概述)(掌握)

•A:封装概述
◦是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

•B:封装好处
◦隐藏实现细节，提供公共的访问方式
◦提高了代码的复用性
◦提高安全性。

• C:封装原则 ◦将不需要对外提供的内容都隐藏起来。
◦把属性隐藏，提供公共方法对其访问。

2.23_面向对象(private关键字的概述和特点)(掌握)

•A:人类赋值年龄的问题
• B:private关键字特点 ◦a:是一个权限修饰符
◦b:可以修饰成员变量和成员方法
◦c:被其修饰的成员只能在本类中被访问

• C:案例演示 ◦封装和private的应用：
◦A:把成员变量用private修饰
◦B:提供对应的getXxx()和setXxx()方法
◦private仅仅是封装的一种体现形式,不能说封装就是私有

class  demo
{
    public static void main(String[] args) {
        student stu = new student();
        stu.getAge();
        stu.setAge(-15);
        stu.getAge();
    }
}
class student
{
    public String name;
    private int age;
    public String sex;
    public void message(){
        System.out.println(name+"---"+age+"---"+sex);
    }
    public void setAge(int a){
        if(a >= 0 && a <= 150)age = a;
        else System.out.println("Worng!");
    }
    public void getAge(){
        System.out.println(age);
    }
    public void study(){

            System.out.println("study");
    }
    public void sleep(){
            System.out.println("sleep");
    }
}

2.24_面向对象(this关键字的概述和应用)(掌握)

• A:this关键字特点 ◦代表当前对象的引用

• B:案例演示 ◦this的应用场景
◦用来区分成员变量和局部变量重名

class  demo
{
    public static void main(String[] args) {
        student stu = new student();
        stu.setName("jack");
        stu.setAge(15);
        System.out.println(stu.getName());
        System.out.println(stu.getAge());
    }
}
class student
{
    private String name;
    private int age;
    public void message(){
        System.out.println(name+"---"+age);
    }
    public void setAge(int age){
        if(age >= 0 && age <= 150)this.age = age;
        else System.out.println("Worng!");
    }
    public int getAge(){
        return age;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void study(){
            System.out.println("study");
    }
    public void sleep(){
            System.out.println("sleep");
    }
}

2.25_面向对象(手机类代码及其测试)(掌握)

•A:学生练习

◦请把手机类写成一个标准类，然后创建对象测试功能。

class demo {
    public static void main(String[] args) {
        Phone p1 = new Phone();
        p1.setBrand("三星");
        p1.setPrice(5288);

        System.out.println(p1.getBrand() + "..." + p1.getPrice());
        p1.call();
        p1.sendMessage();
        p1.playGame();
    }
}
/*
手机类
    属性:品牌brand,价格price
    行为:打电话call,发短信sendMessage,玩游戏,playGame
*/
class Phone {                               //java bean
    private String brand;                   //品牌
    private int price;                      //价格

    public void setBrand(String brand) {    //设置品牌
        this.brand = brand;
    }

    public String getBrand() {              //获取品牌
        return this.brand;                  //this.可以省略,你不加系统会默认给你加
    }

    public void setPrice(int price) {       //设置价格
        this.price = price;
    }

    public int getPrice() {                 //获取价格
        return price;
    }

    public void call() {                    //打电话
        System.out.println("打电话");
    }

    public void sendMessage() {             //发短信
        System.out.println("发短信");
    }

    public void playGame() {                //玩游戏
        System.out.println("玩游戏");
    }
}