黑马程序员技术交流社区

标题: Java基础每日总结 [打印本页]

作者: 马赛 时间: 2015-11-30 21:14
标题: Java基础每日总结
今天算是正式来论坛的第一天，正愁有没有什么好的学习方法，然后看到有人会来论坛进行每天的学习总结。
虽然我已经学习基础课7天了，但是我觉得现在还不晚，这样不仅可以督促自己复习每天的学习，还可以给加深一次印象，何乐而不为呢。{:2_40:}
今天先写一下昨天，也就是第七天的总结，然后会一点点把之前的补上，毕竟一下都弄完也不好消化

作者: 马赛 时间: 2015-11-30 21:19
先从第六天开始写吧，因为第六天是面向对象的第一天，可以讲后边的内容串联起来，也是一个重要的内容

作者: bbaijiajinger 时间: 2015-11-30 21:57
你写的东西呢
我还想借着
复习一下前面学的东西呢

作者: hyl 时间: 2015-11-30 22:06
努力，加油。

作者: 马赛 时间: 2015-11-30 22:17
第六天参照老师发的ppt第一页的学习内容回忆的，有哪些说的不对的地方，还要各位指出来，大家互相学习互相提高
开始学习面向对象，也预示学习要开始头疼了（重点内容）
一，面向对象思想
      面向对象学习之前，先了解了一下面向过程，前几天学习用到的思想都属于是面向过程思想，都是在一个main方法里边创建N多个自定义方法，然后再main方法里使用自定义方法，这样的写法代码量小的话没有什么，但是代码量多的话，对于后边对代码的整理和功能的扩展都不太，面向对象更趋近于人的思想，在项目的后期维护上边也会非常方便。
   面向过程我们是具体的执行者，面向对象我们可以是指挥者。面向对象思想是从面向过程思想演变而来的。
   面向过程：煎饼：买各种材料 --- 和面 --- 起火 --- 放面 --- 放鸡蛋 --- 放葱花抹酱 --- 吃煎饼
   面向对象：找到煎饼摊老板 --- 老板来个煎饼 --- 不要煎不要饼 --- 老板把煎饼给你 --- 你吃煎饼

   万物皆对象！
   面向对象的三个特征：封装、继承和多态
二、类与对象及其使用
      面向对象就是讲一些有相同属性的东西封装到一起，封装的东西就是类，人可以算是一个类（人类），而人中的一个个体张三，就是人类的一个对象，一个类中可以有属性和方法，对应的现实中的人类就是人的属性和行为。类中的属性和方法称为成员属性（成员变量）和成员方法。
      类是java语言中最基本的单位。类是一组相关属性和行为的集合。
      类中的属性和方法可以和现实中的事物一一对应。
      属性：名词（变量）
      行为：动词（方法）
   学生类的代码演示：

class Student{
String name;//学生有姓名
int age;//学生有年龄
int num;//学生有学号
public void study(){//学生有学习行为（方法）
System.out.println("学生能学习");
}
}

复制代码

   对象：类的实例化就是对象，对象的抽象称为类
      创建对象：类名对象名 = new 类名();
      可以通过对象调用类中的属性和方法：对象名.成员变量对象名.成员方法
三：对象的内存图
      1. javac编译源码，.class文件加载到内存的方法区
      2. main方法进栈，有一个 Student s1 （栈内存）
   3. 在堆内存中创建Student的对象s1
      4. String name 默认值 null，int age 默认值 0，int number 默认值 0
      5. 将s1在堆内存中的地址赋给 Student s1 ，main方法中的s1指向堆内存中的对象
      6. 使用Student中的study方法，Student.class 文件加载到方法区
      7. study方法进栈，main中的s1把内存地址赋给study方法，方法指向堆内存的对象
   8. 方法用完以后，study方法弹栈，main方法弹栈，指向消失，堆内存中的对象被java回收机制自动回收
四、成员变量和局部变量的区别
      1. 位置不一样：成员变量在类里方法外，局部变量在方法里和方法的声明上
      2. 声明周期不一样：成员变量随着对象创建产生随着对象回收而消失，局部变量随着方法调用产生，方法弹栈而消失
      3. 初始化值不一样：成员变量系统会有默认值，局部变量需要自己初始化，如果不初始化会编译错误
                                    byte short int long 默认值 0
                                    float double 默认值 0.0
                                    char 默认值 '\u0000'
                                    boolean 默认值 false
                                    其他引用类型默认值 null
   4. 在内存中的位置不一样：成员变量在堆内存，局部变量在栈内存。
      注意：局部变量和成员变量名字相同时，采用就近原则
五：匿名对象：没有名字的对象，只能使用一次，是作为实际参数传递的
六：封装（private）
      属性私有化，对外提供set和get方法
      属性私有，可以在类里进行安全验证，提高代码的安全性和健壮性
      封装原则：将不需要对外提供的内容隐藏起来，属性隐藏，提供公共方法
      被private修饰的成员只能在本类中才能访问
七、this关键字
      this关键字目前了解的不是特别清除
      方法被哪个对象调用，this就代表那个对象，在set方法上，如果参数和属性名一样，要使用this.

   附上第六天的ppt和总结

day_06.rar

385.2 KB, 下载次数: 180

作者: 马赛 时间: 2015-11-30 22:21

bbaijiajinger 发表于 2015-11-30 21:57
你写的东西呢
我还想借着
复习一下前面学的东西呢

刚写完。。。可以看了，第六天的，有什么不对或者需要补充的可以互相交流

作者: eddy1820 时间: 2015-11-30 22:25
剛上完第三天，感謝分享

作者: 马赛 时间: 2015-11-30 22:28

eddy1820 发表于 2015-11-30 22:25
剛上完第三天，感謝分享

为什么你的技术分那么高

作者: 13542010298 时间: 2015-11-30 22:31
有用！！！！！！！！

作者: lcm 时间: 2015-11-30 23:05
加油～～～

作者: 袁有福123 时间: 2015-11-30 23:26
谢谢分享

作者: bbaijiajinger 时间: 2015-11-30 23:26
内存分为五个区

栈，堆，方法区、本地方法区、寄存器

作者: 冷光之神 时间: 2015-11-30 23:41
写的不赖

作者: 马赛 时间: 2015-11-30 23:51

bbaijiajinger 发表于 2015-11-30 23:26
内存分为五个区

栈，堆，方法区、本地方法区、寄存器

另外两个用不到呢，谢谢补充

作者: usaoak 时间: 2015-11-30 23:59
能做到坚持很不容易。顶了……支持。

作者: 马赛 时间: 2015-12-1 00:22
一、构造方法（重点、掌握）
构造方法是用来创建对象的，写法和前边学到的public static void xxx 和 public void xxx 类似
只不过构造方法没有返回值，也没有void，方法名要和类名一模一样
构造方法分为无参构造方法和有参构造方法，自己如果没有写构造方法，系统会有一个默认的无参构造方法
Student类的构造方法

class Student{
String name;
int age;
//无参构造方法
public Student(){
}
//有参构造方法
public Student(String name, int age){
this.name = name;
this.age = age;
}
}

复制代码

成员变量的赋值方法
1,set和get方法
2,构造方法传递参数

二、成员方法的分类和使用

//无返回值
public void noValue(){
System.out.println(100);
}
//有返回值
public int hasValue(){
return 100+200;
}
//有参
public void hasParam(int num){
System.out.println(num);
}
//无参
public void noParam(){
System.out.print("100+200");
}

复制代码

三、基本类的标准写法
这个是老师的经验分享，写类的一般步骤
1，private属性
2，构造方法，先写无参再写有参的
3，成员方法
4，set和get方法
5，用不到的可以不写，代码依附于需求
拿Student当例子

class Student{
private String name;
private int age;
public Student(){
}
public Student(String name, int age){
this.name = name;
this.age = age;
}
public void study(){
System.out.println(name + "今年" + age + "岁");
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
}
class StudentDemo{
public static void main(String[] args){
//使用set方法赋值
Student s1 = new Student();
s1.setName("张三");
s1.setAge(18);
s1.study();
System.out.println("-----");
//使用构造方法赋值
Student s2 = new Student("李四", 20);
s2.study();
}
}

复制代码

四、创建一个对象的步骤
同第六天
五、static关键字
方法区里边有一个静态区，可以放静态变量和静态方法，static数据就放在方法区
静态的东西随着类的加载而加载
优先于对象存在
静态变量可以被公用
如果一个变量需要被对象共享，就应该使用static关键字
直接通过类名调用，最开始学习方法的时候都是用的static修饰
静态只能调用静态
静态变量和成员变量的区别
静态变量属于类，随着类的加载而加载
成员变量属于对象，随着对象的创建而加载
静态变量存储在方法区中的静态区
成员变量存储在堆内存
静态变量优先于成员变量，所以不能用对象.来调用静态变量
六、main方法
public static void main(String []){}
public : 公共的，权限最大的
static ：静态的，通过类名.直接调用
void ：没有返回值的
main ：一个被特殊化的方法名，如果写错，java虚拟机不会启动
String[] args ：字符串数组类型的参数，以前用于接收键盘录入
在控制台输入 java 类名.java 数据1 数据2 数据3 ...
会传入字符串类型的参数
可以通过以下代码获得args的内存地址

class Demo{
public static void main(String[] args){
System.out.println(args);
}
}

复制代码

七、Api文档

/**
* 当前类是可以对数组做常见操作的类
*
* @author
* @version
*/
public class ArrayTool {
private ArrayTool() {}
/**
* 遍历数组中的每个元素，显示出来
* @param arr 请传入一个数组
*/
public static void print(int[] arr) {
...
}
/**
* 判断num数字是否存在数组arr中，返回它的下标位置
* @param arr 请传递一个数组
* @param num 请传入一个数字
* @return -1、没有找到，否则返回下标值
*/
public static int getIndex(int[] arr, int num) {
...
}
}

复制代码

   使用 javadoc -d .\帮助文档 -author -version ArrayTool.java 可以创建帮助文档
      打开新建的帮助文档文件夹，找到 index.html 就是帮助文档
      通过Api查看Math方法，Math方法的父类是java.lang，所以不用导包，因为lang包里的方法会经常被用到
      基本的数学方法都可以在Math类中找到
      Math没有构造，都是静态成员和方法，直接用Math.调用
      学习Math类中的random随机数方法（大于0小于1）
   获得1-100之间的随机数的代码

import java.util.Scanner;
class GuessGame{
public static void main(String[] args){
//使用Math类中的random方法
//random方法返回的是double类型，需要强制转换
int randomNum = (int)(Math.random()*100)+1;
Scanner sc = new Scanner(System.in);
//人机交互
System.out.println("请输入你猜的数字(1-100)");
//因为不知道循环次数，所以使用while循环
while(true){
int guessNum = sc.nextInt();
if(guessNum > randomNum){
System.out.println("大了，请重猜");
}else if(guessNum < randomNum){
System.out.println("小了，请重猜");
}else{
System.out.println("恭喜，猜对了");
break;
}
}
System.out.println("游戏结束！");
}
}

复制代码

附上第七天ppt和总结

day_07.rar

367.89 KB, 下载次数: 119

作者: ^_^笨和尚^_^ 时间: 2015-12-1 00:49
总结的很不错，值得学习

作者: 马赛 时间: 2015-12-1 12:19
上午继承里边的构造方法有点晕

作者: 乌合屁民 时间: 2015-12-1 20:24
恩不错不错~~~~

作者: 洋葱头头 时间: 2015-12-1 20:35
感谢楼主

作者: bbaijiajinger 时间: 2015-12-1 21:27
哎呀，大神的节奏啊

作者: 袁有福123 时间: 2015-12-1 21:54
感谢分享！！

作者: 马赛 时间: 2015-12-1 22:16
第八天的
一、代码块
有三种：
1、局部代码块
方法体里，for循环里的大括号就是一个局部代码块

public static void main (String[] args){
{
int num = 100;//作用域在大括号里边，使用后立即释放
}
}

复制代码

2、构造代码块
类里方法外,每次new一个对象，就执行一次

class ClassA{
{
System.out.println("构造代码块");
}
public ClassA(){
}

复制代码

3、静态代码块
在类加载的时候加载到方法区里的静态区，只执行一次

class ClassB{
static{
System.out.println("静态代码块");
}
}

复制代码

代码块可以使用非正式的模拟数据进行对代码的测试

class BlockDemo{
static int[] scores = new int[3];
//使用静态代码块对数组进行初始化
static {
score[0] = 20;
score[1] = 30;
score[2] = 40;
}
public static void main(String[] args){
print(scores);
int index = getIndex(scores);
System.out.println("获得的角标是："+i);
}
//定义一个数字遍历方法
public static void print(int[] arr){
for(int i = 0; i<arr.length; i++){
System.out.print(arr[i]);
}
System.out.println();
}
//定义一个数组角标查询方法
public static int getIndex(int[] arr){
int index = -1;
for(int i = 0; i<arr.length; i++){
if(arr[i] == 30){
index = i;
}
}
return index;
}
}

复制代码

二、继承(重点,难点)
多个类具有相同属性和行为，将这些相同的属性和行为封装到另外一个类中，可以使代码的工作量减少，同时
也利于对代码的维护。
继承的语法
      class 子类名 extends 父类名
      父类可以叫做基类，也可以叫做超类
      子类可以叫做派生类
      子类在继承父类公有属性和方法的同时自己还可以扩充属于自己的属性和方法
      通过老师、学生和人来演示

//老师类和学生类具有一些共同的属性和方法，这些属性和方法定义在了人类里
class Person {
// 人类具有的属性(老师和学生同时也具有的属性)
String name;
int age;
// 构造方法
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 成员方法
public void eat() {
System.out.println("吃饭");
}
public void sleep() {
System.out.println("睡觉");
}
// set,get方法
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return this.age;
}
}
//定义一个学生类，学生类继承person类
class Student extends Person {
private String number;//学生特有的属性
public Student(){
}
public Student(String name, int age, String number) {
super(name,age);
this.number=number;
}
public void study() {//学生特有的学习方法
System.out.println("学习");
}
public void setNumber(String number){
this.number = number;
}
public String getNumber(){
return number;
}
}
//定义一个老师类
class Teacher{
private double salary;//老师特有的属性
public Teacher(){
}
public Teacher(String name, int age, double salary){
super(name,age);
this.salary = salary;
}
public void teach(){//老师特有的授课类
System.out.println("老师上课");
}
public void setSalary(String salary){
this.salary = salary;
}
public String getSalary(){
return salary;
}
}
/*运行类*/
class ExtendsDemo{
public static void main(String[] args){
}
}

复制代码

继承有优点也有缺点
优点：节省代码量，便于维护和代码的复用
缺点：耦合性强

如果父类和子类中的成员变量名相同了，就要使用this和super来调用成员变量

class A {
int num = 30;
}
class B extends A {
int num = 20;
public void method() {
int num = 10;
System.out.println(num);// 10
System.out.println(this.num); // 20
System.out.println(super.num); // 30
}
}

复制代码

继承可以多层继承，但是不能多重继承，即：可以 class A extends B extends C{} 但是不能 class A extends B,C{}
子类只能继承父类的非私有成员，子类不能继承父类的构造方法，但是可以通过super关键字访问父类构造方法
子类构造方法在初始化的时候，要先初始化父类的构造方法，然后再做子类的构造方法
当几个类存执 a is b的结构时才可以使用继承机制，不能说两个类都有同一个名字的方法就要用继承机制
比如猫和手机都有玩游戏的方法，但是它们之间没有a is b的关系，所以不能使用继承机制
在一个子类中访问一个变量
   1.现在子类局部范围找
   2.在子类成员范围找
   3.在父类成员范围找，不能在父类局部范围里找
   4.如果没有就会报错
继承中一个内容，方法的重写，和之间学过的方法重构还是有区别的
如果子类和父类中有相同名字的一个方法，子类如果向要扩充或改写此方法，就需要用到方法的重写
重载是针对于一个类中方法的
      方法名字定义成一个是方便程序员使用，但是根据参数的方式自行匹配
重写是针对于继承机制中的多个类的方法
重写的目的，对父类的代码进行扩展，或者变化特别大完全覆盖

      先弄这么多，好多东西还没弄明白，看视频了

作者: Myth、骞 时间: 2015-12-1 22:20
看了一遍，复习一遍-。-准备入学面试中

作者: xiao15779706 时间: 2015-12-2 08:54
感谢分享

作者: Kalsifa 时间: 2015-12-2 10:35
不错，加油加油！

作者: 孙志明 时间: 2015-12-2 10:52
真是厉害啊

作者: 马赛 时间: 2015-12-3 22:06
第九天这几天面向对象，抽象内容比较多，有点不知道该如何着手去学习这一块，各位有什么好的方法不妨说一下，也是和大家分享交流

这是昨天的课程了，今天休息一天，昨天上课的时候，刚开始讲父类引用指向子类对象的时候，怎么也听不进去，吸收不了知识，因为我总在想到底为什么访问变量要看左边，访问方法要看右边，总是想不通内存图里怎么走的，感觉要一点都学不下去似的，后来我也不想了，然后就死记这个结论，还算可以，能够在遇到此类的问题的时候，知道该看哪里运行哪里编译，然后就是感觉，现在的话想要把什么都弄明天有点不现实，时间和精力都不允许，所以，能快速吸收消化的就赶紧吸收了，不要因为纠结那么一点点为什么，把其他的知识点扔一边不去管，这也算是昨天上课的一点感悟吧。然后下边是昨天的总结，感觉自己语言组织能力太差了，光靠自己想东西来总结有点头疼，而且脑子会很空，所以参考着老师的总结写完了，相当于又复习一遍吧
一、多态
多态就是一个事物有多种状态，比如（水：液态、固态、气态）
多态的三个前提：
1.有继承关系
2.方法重写
3.父类引用指向子类对象
父类引用指向子类对象：
1.访问变量：编译看左边，运行看左边
2.访问成员方法：编译看左边，运行看右边
3.访问静态方法：编译看左边，运行看左边
调用静态方法：可以通过类直接访问，也可以通过
对象访问，但本质是类名访问，所以调用静态方法
不存在多态，这个是一个假象。静态方法不算方法的重写
类型提升：
向上提升：小类型向大类型转换，父类对象名 = new 子类();
向下转型: 父类引用上进行强制转换，子类对象名 = (子类)父类对象名;
类型提升解决了多态的弊端，父类不能访问子类的独有的方法
多态的好处和弊端：
1.提高代码的维护性，由继承保证，大量的代码写在了父类中
2.提高程序扩展性：由多态保证
3.多态中父类不能访问子类中独有的方法
二、抽象类
抽象abstract，不是具体的一个物体，属于一类，要用抽象类来定义，在以后的工作中要考虑是
用抽象还是普通类
抽象类的注意事项：
有构造方法，不能进行实例化，要由具体的子类实例化，用多态实现
抽象类不一定有抽象方法，但是有抽象方法的类一定是抽象类
抽象类的成员：成员变量可以是变量，也可以是常量
成员方法：可以是普通方法，也可以是抽象方法
抽象类的子类可以有两种，一种可以是抽象类，一种可以是普通类，但是普通类要重写父类里的抽象方法
抽象类也可以有父类
abstract不能和哪些关键字一起用？
1.private：抽象类，希望别人实现方法，被private修饰会冲突
2.final：被final修饰以后不能重写方法
3.static
三、接口
接口 interface，可以给一个类提供而外的功能，使用 implement 实现接口，也算是对继承只能单继承弊端的一个解决方法
接口中的成员只能是常量和抽象方法,要实现接口就要全部实现抽象方法
接口是能力的扩展，不会对本质产生影响
比如一个门，可以在门的基础上添加门铃，门铃就可以看作是对门能力的扩充，门铃就是一个接口
接口的注意事项：
接口主要是对能力的扩充，没有new构造方法
定义的变量在接口里会变成常量，所以标识符所有字母都要大写，有个隐藏的 public static final
java源码中很多都是用接口来写的，因为java不受行业约束
类和类的关系：
继承关系，只能单继承，不能多继承，能多层继承，不能多重继承
类和接口的关系：
实现关系，类来实现接口的方法，单实现也可以多实现
接口和接口的关系：
可以继承，多继承（没有讲）
抽象类和接口关系：
实现接口
抽象类可以有变量、常量、成员方法、抽象方法
接口只能有常量和抽象方法

第九天ppt和总结

Day_09.rar

392.05 KB, 下载次数: 20

作者: 马赛 时间: 2015-12-3 22:31
第五天
第五天讲的是一维数组和二维数组，当时学完二维数组以后做了杨辉三角题目，课上自己想没有想出来，然后老师讲课的时候我有点走私，还在自己想怎么做，以至于后来老师解析完这道题，我还是没弄懂，到晚自习结束我也没心思弄这道题，后来回宿舍，十一点多的时候舍友说看一下杨辉三角，然后我说我也看一下，结果突然就想明白了，然后当时就能自己把代码写出来，我想说的有2点，一个是上课老师讲课一定要认真听，然后就是有不会的不要急，先缓一下，没准什么时候就突然开窍了，当然不能耽误太长时间
第五天内容总结，其实像这种数字类的知识，多想想就明白了，但是面向对象讲的是思想，真的是不好弄明白
一、数组（重点、难点、掌握）
      什么叫做数组：用来装一堆相同数据类型数值的容器叫做数组
      一维数组格式：
            数组类型[] 数组名(一般用这种格式)
            数组类型数组名[]
      动态初始化
            数组类型[] 数组名 = new 数组类型[m];
            动态初始化定义了数组的长度，但是没有定义数组内容，系统会给数组分配默认值
                     int类型的默认值是0
                     浮点型默认值 0.0
                     char类型默认值 "\u0000"
                     String默认值 null
                     boolean默认值 false
      静态初始化
            数组类型[] 数组名 = {数据1, 数据2, 数据3, 数据4, 数据5}
            静态初始化给出了数组里边的内容，系统会自动判断数组长度
      获得数组长度的方法：
            数组名.length
      数组即可以存储基本数据，也可以存储引用数据
      通过数组引出来内存中栈、堆和方法区（面向对象讲）
            栈内存：用来存储局部变量
            堆内存：用来存储new出来的对象
      数组在内存中是通过数组在内存中的地址来进行指向的
二、二维数组（理解）
      二维数组的格式
            数组类型[][] 数组名
            数组类型数组名[][]
      二维数组动态初始化
            有2种
            数组类型[][] 数组名 = new 数组类型[m][n]
            数组类型[][] 数组名 = new 数组类型[m][]
            m代表二维数组最外边的大括号，表示行，包含n
            n代表二维数组里边的大括号，表示列，被m包含
            int[][] arr = new int[m][n];
            表示int数组类型的arr，里边有m个一维数组，每个一维数组有n个数据
      二维数组静态初始化
            数组类型[][] 数组名 = new 数组类型[][]{{},{}};
            数组类型[][] 数组名 = {{1,2,3,4},{3,4},{3},{2,3}};
      注意：静态初始化数组，大括号后边有一个分号
            还可以这样
            int[ ][ ] arr = new int[3][ ];
            arr[0] = new int[2];
            arr[1] = new int[3]
            arr[2] = new int[1];

Day_05.rar

319.64 KB, 下载次数: 20

作者: shuozi321456 时间: 2015-12-3 22:36
不错不错

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2