[Java知识库]【JAVA黑马程序员笔记】一P1到P168（基础知识、继承、封装、修饰符、ArrayList、String、StringBuilder、IDEA快捷使用）

Hello,World

public class Demo{
    public static void main(String args[]){
               System.out.println("Hello,World");

 }
}

请注意这个代码的命名应该为Demo.java，与类的名称相同
然后：

javac Demo.java
java Demo

P12 变量

1. 注意默认的整数类型为int，默认的小数类型为double，则：float = 3.14F如果没有后缀F将容易报错

P29 数据输入

import java.util.Scanner; // 导入包

	Scanner sc = new Scanner(System.in);
		int i = sc.nextInt();

P36 if语句

	//if操作
	if(true)
{
	System.out.println("i m if");

} else 
{
	System.out.println("i m if 2");
}

P39 for循环

	for(int i=1;i<=5;++i)
		Systemp.out.printIn("helloworld!!");

P45 while循环

	// while操作
	while(i>0) // 注意不能直接再括号内写i--
{
	i--;
	System.out.println("i m while!!!");
}

P51 Random函数

import java.util.Random;
		int number = r.nextInt(100)+1; // 1 - 100之间的随机数
		System.out.println("the random number:" + number);

P56 IDEA内容辅助键和快捷键

psvm回车快速生成main函数
sout回车快速生成输出语句
ctrl+alt+space 内容提示和代码补全
ctrl+/ 单行注释和取消注释
ctrl+alt+space多行注释和取消注释
ctrl+alt+l格式化
ctrl+alt+v在调用方法的时候，若方法有明确的返回值，可以快速生成接收变量
alt+insert可以快速生成一些构造函数，get set方法等。。
alt+enter可以对于异常处的方法。。。。怎么怎么（后面还没学到），也可以用于导入包
view->Tool Windows->Structure或者按alt+7可以出现结构的窗口

1. 假如父类有一个方法名字叫做eat(),子类要重写他，则直接打名字eat，IDEA将帮助生成。。。
2. 看方法源码：选中方法，然后按下ctrl+B

P59 数组动态初始化方式

int[] arr = new int[3]; // 数组类型 []说明是个数组 arr是数组名称 3是数组的个数

P65 数组初始化之静态初始化

int[] arr = new int []{1,2,3};
//或者是下面的简化格式，推荐：
int[] arr = {1,2,3};

P66 数组操作的两个常见小问题

1.索引越界
2.空指针异常（arr = null;//则不能访问他）

P67 遍历

arr.length //获取数组的长度

P69 方法

感觉是函数。。
// 定义

public static void func()
{
	int number = 10;
	if(number %2 == 0)
		System.out.println(true);
	else
		System.out.println(false);
}

func(); // 调用方法  注意方法要先定义后调用

// 注意boolean类型是bool再java的名称，注意定义变量的时候没搞错

P78 方法的注意事项

1.方法不能嵌套定义
2.void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据
3.方法定义时若没指明public或者private，会有默认的权限，默认权限比public小

P80 方法重载

1.多个方法再同一个类中
2.多个方法具有相同的方法名
3.多个方法的参数不相同，类型不同或者数量不同

P83 引用类型做形参

这将影响实参的结果

P101 对象的使用

        Phone p = new Phone();

        p.brand = "xiaomi";
        p.price = 1000;
        System.out.println(p.brand);
        System.out.println(p.price);

        p.call();
        p.sendMessage();

P106 成员变量和局部变量

成员变量:类中方法外的变量
局部变量：在方法内或方法生命上

P107 private

private int a = 10; // 使用private关键字设置为私有

P109 this修饰

this解决局部变量隐藏成员变量
this代表所在类的对象引用，方法被哪个对象调用，this就代表哪个对象。

    public void setName(String nanme)
    {
        this.name = name;  // this修饰的name是成员变量
    }

P112 构造方法

//无参构造方法
    public Student(){
        System.out.println("无参构造方法");
    }
    public Student(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("有残构造方法");
    }

当我们没有给出任何构造方法的时候，系统将提供默认的构造方法，建议手工写一个无参构造方法

P116 键盘录入字符串学习

package ScannerPkg;
import java.util.Scanner;
public class ScannerDemo {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);

        System.out.println("plz input a number:");
        String line = s.nextLine();


        System.out.println("the number u input:" + line);

    }
}

P117 String

String的构造方法

public class StringDemo01 {

    public static void main(String[] args) {
        String s1 = new String();
        System.out.println("s1:" +s1);

        char[] chs = {'a','b','c'};

        String s2 = new String(chs);
        System.out.println("s2:" + s2);

        byte[] bys = {97,98,99};
        String s3 = new String(bys);
        System.out.println("s3:" + s3);

        String s4 = "abc";

        System.out.println("s4:"+s4);


    }

}

String的特点

1. 通过new得到的两个String变量，他们的地址不同
2. 通过""方式得到的两个String变量，如果他们内容相同，则他们的地址相同，本质上是一个对象。

P120 字符串的比较

s1.equals(s2)

P122 遍历字符串

获得字符串的某个字符：

s.charArt(0); // 获得s[0]

P128 StringBuilder

首先说StringBuilder和String的区别：
String是常量，是不可改变的
StringBuilder是可变的。

       StringBuilder sb = new StringBuilder();
        System.out.println("sb:" + sb);
        System.out.println("sb.length():" +sb.length());


        StringBuilder sb2 = new StringBuilder("hello");

        System.out.println("sb2:"+sb2);
        System.out.println("sb2.length()"+sb2.length());

        StringBuilder sb3 = sb2.append("world");

        // 练市编程
        sb3.append(300).append("testttttt").append("append");
        System.out.println("sb3:" + sb3);
        sb3.reverse();
        System.out.println("sb':"+sb3);

        // StringBuilder 和 String 相互 转换
        // way 1
        String s = sb3.toString();

        // String to StringBuilder :
        String s1 = "hello";
        StringBuilder s1_sb = new StringBuilder(s1);

P134-P136

ArrayList的用法

     ArrayList<String> array = new ArrayList<String>();

        array.add("hello");
        array.add("world");
        array.add("java");

        array.add(3,"javaee");

        array.add(1,"javase");
        System.out.println("array:" +array);

        // 常用的方法

        System.out.println(array.remove(3)); // 删除病返回
        System.out.println(array.set(1,"heihei")); // 修改索引处元素
        System.out.println(array.get(0)); // 返回制定索引处的元素
        System.out.println(array.size()); // 返回元素个数

P150 继承

用法: public class 子类 extends 父类

== 继承的好处和坏处==

1. 提高了代码的复用性
2. 提高了代码的维护性
3. 提高了类的耦合性

什么时候使用继承？

1. 继承体现的关系 : is a
2. 猫是动物；苹果是水果。
   继承中变量的访问特点

在子类方法中寻找一个变量的顺序：先在子类局部范围找，然后在子类成员范围找，最后在父类成员范围找（不考虑父亲的父亲），成员方法的访问特点和这个的搜索相同。

子类使用父类的变量

在本类的方法中，使用super.member 来获得member变量的值。

== 继承中构造方法的访问特点==
子类中所有的构造方法默认都会访问父类中午餐构造方法

1. 子类初始化前，一定先完成父类的初始化
2. 每一个子类构造方法的第一条语句默认都是：super(),一般不写，让系统自动生成。
3. 如果想使用子类有参构造方法默认调用父类的带参构造方法，可以使用super(args)的方法，把父类有参构造方法所需要的参数给传入到super()中，并且把这个代码加入到程序内。
4. 若父类中没有无参构造方法，而子类又想用super()方法调用无参构造方法， 那么就最好再父类中自己提供一个无参构造方法。

继承注意事项

1. java不能多继承，只能继承一个类
2. java中类支持多层继承

P157 方法重写

使用@Override显示的声明下面的函数是重写父类的,这个注解可以帮忙检查重写方法的方法声明的正确性：

   @Override
    public void call(String name)
    {

        System.out.println("开启视频功能");
        //System.out.println("gei" + name + "da dian hua!");
        super.call(name);
    }

子类重写的注意事项

1. 父类中的private方法是不能重写的
2. 子类重写父类函数时，要保证子类方法的访问权限不能比父类低（public > 默认 > 私有）

P162 包Package

包其实就是文件夹，用来对类进行分类管理
包的定义格式：package 包名（多级包用.分开） 这种方法是用记事本写.java来实现包的生成的，当然用IDEA的话会很简单

package com_itheima;

public class HelloWorld {
    public static void main(String[] args){
        System.out.println("hello,world");
    }

}

第一行的意思就是在这个包下，对于这个HelloWorld.java的文件，首先运行

javac HelloWorld.java

生成编译文件,然后自己新建一个HelloWorld的文件夹，把生成的class文件放到那个的下面，然后运行：

java com_itheima.HelloWorld

就行了
也可以自动建包（当前目录下）：
.表示当前目录下

javac -d . HelloWorld.java
java com_itheima.HelloWorld

P163 import

假如说两个包pkg1和pkg2有下面结构：
pkg1
-student.java
-teacher.java
pkg2
demo.java

我们想用pkg2的demo.java调用pkg1的类，则可以：

	pkg1.student s = pkg1.student();
	pkg1.teacher t = pkg1.teacher();

除了上面的方法，也可以再demo.java中先引用这个类：

import pkg1.teacher;
import pkg1.student;

.....
	teacher t = new teacher();
	student s = new student();


....

P164 权限修饰符

P165-P168 final，static状态修饰符

1. final修饰方法，则方法不能被重写。
2. final修饰变量，则变量是常量不能被赋值。
3. final修饰类，则类不能被继承。
4. final修饰局部变量，若是基本类型，则指的是基本类型的数据值不能改变。
5. final修饰局部变量，若是引用类型，则指的是引用类型的地址值不能改变，而地址的内容是可以改变的。
6. static修饰的特点，被所有的对象共享
7. 静态成员方法只能访问静态成员，非静态成员方法则都能访问。