A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 马赛 中级黑马   /  2015-11-30 21:14  /  1930 人查看  /  29 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

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

29 个回复

倒序浏览
先从第六天开始写吧,因为第六天是面向对象的第一天,可以讲后边的内容串联起来,也是一个重要的内容
回复 使用道具 举报
你写的东西呢
我还想借着
复习一下前面学的东西呢
回复 使用道具 举报
hyl 中级黑马 2015-11-30 22:06:22
板凳
努力,加油。
回复 使用道具 举报
第六天    参照老师发的ppt第一页的学习内容回忆的,有哪些说的不对的地方,还要各位指出来,大家互相学习互相提高
    开始学习面向对象,也预示学习要开始头疼了(重点内容)
    一,面向对象思想
        面向对象学习之前,先了解了一下面向过程,前几天学习用到的思想都属于是面向过程思想,都是在一个main方法里边创建N多个自定义方法,然后再main方法里使用自定义方法,这样的写法代码量小的话没有什么,但是代码量多的话,对于后边对代码的整理和功能的扩展都不太,面向对象更趋近于人的思想,在项目的后期维护上边也会非常方便。
       面向过程我们是具体的执行者,面向对象我们可以是指挥者。面向对象思想是从面向过程思想演变而来的。
       面向过程:煎饼:买各种材料 --- 和面 --- 起火 --- 放面 --- 放鸡蛋 --- 放葱花抹酱 --- 吃煎饼
       面向对象:找到煎饼摊老板 --- 老板来个煎饼 --- 不要煎不要饼 --- 老板把煎饼给你 --- 你吃煎饼

       万物皆对象!
       面向对象的三个特征:封装、继承和多态
    二、类与对象及其使用
        面向对象就是讲一些有相同属性的东西封装到一起,封装的东西就是类,人可以算是一个类(人类),而人中的一个个体张三,就是人类的一个对象,一个类中可以有属性和方法,对应的现实中的人类就是人的属性和行为。类中的属性和方法称为成员属性(成员变量)和成员方法。
        类是java语言中最基本的单位。类是一组相关属性和行为的集合。
        类中的属性和方法可以和现实中的事物一一对应。
        属性:名词(变量)
        行为:动词(方法)
       学生类的代码演示:   
  1. class Student{
  2.         String name;//学生有姓名
  3.         int age;//学生有年龄
  4.         int num;//学生有学号
  5.         public void study(){//学生有学习行为(方法)
  6.                 System.out.println("学生能学习");
  7.         }
  8. }
复制代码
       对象:类的实例化就是对象,对象的抽象称为类
        创建对象:类名 对象名 = 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, 下载次数: 183

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

刚写完。。。可以看了,第六天的,有什么不对或者需要补充的可以互相交流
回复 使用道具 举报
剛上完第三天,感謝分享
回复 使用道具 举报
马赛 中级黑马 2015-11-30 22:28:19
8#
eddy1820 发表于 2015-11-30 22:25
剛上完第三天,感謝分享

为什么你的技术分那么高
回复 使用道具 举报
13542010298 来自手机 中级黑马 2015-11-30 22:31:35
9#
有用!!!!!!!!
回复 使用道具 举报
lcm 来自手机 中级黑马 2015-11-30 23:05:06
10#
加油~~~
回复 使用道具 举报
谢谢分享
回复 使用道具 举报
内存 分为五个区

栈,堆,方法区、本地方法区、寄存器
回复 使用道具 举报
写的不赖                        
回复 使用道具 举报
马赛 中级黑马 2015-11-30 23:51:14
14#
bbaijiajinger 发表于 2015-11-30 23:26
内存 分为五个区

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

另外两个用不到呢,谢谢补充
回复 使用道具 举报
usaoak 初级黑马 2015-11-30 23:59:00
15#
能做到坚持很不容易。顶了……支持。
回复 使用道具 举报
一、构造方法(重点、掌握)
    构造方法是用来创建对象的,写法和前边学到的public static void xxx 和 public void xxx 类似
    只不过构造方法没有返回值,也没有void,方法名要和类名一模一样
    构造方法分为无参构造方法和有参构造方法,自己如果没有写构造方法,系统会有一个默认的无参构造方法
    Student类的构造方法
  1. class Student{
  2.         String name;
  3.         int age;
  4.         //无参构造方法
  5.         public Student(){
  6.        
  7.         }
  8.         //有参构造方法
  9.         public Student(String name, int age){
  10.                 this.name = name;
  11.                 this.age = age;
  12.         }
  13. }
复制代码

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

二、成员方法的分类和使用
  1. //无返回值
  2.         public void noValue(){
  3.                 System.out.println(100);
  4.         }
  5.         //有返回值
  6.         public int hasValue(){       
  7.                 return 100+200;
  8.         }
  9.         //有参
  10.         public void hasParam(int num){
  11.                 System.out.println(num);
  12.         }
  13.         //无参
  14.         public void noParam(){
  15.                 System.out.print("100+200");
  16.         }
复制代码

三、基本类的标准写法
        这个是老师的经验分享,写类的一般步骤
        1,private属性
        2,构造方法,先写无参再写有参的
        3,成员方法
        4,set和get方法
        5,用不到的可以不写,代码依附于需求
    拿Student当例子
  1. class Student{
  2.         private String name;       
  3.         private int age;
  4.         public Student(){
  5.        
  6.         }
  7.         public Student(String name, int age){
  8.                 this.name = name;
  9.                 this.age = age;
  10.         }
  11.         public void study(){
  12.                 System.out.println(name + "今年" + age + "岁");
  13.         }
  14.         public void setName(String name){
  15.                 this.name = name;
  16.         }
  17.         public String getName(){
  18.                 return name;
  19.         }
  20.         public void setAge(int age){
  21.                 this.age = age;
  22.         }
  23.         public int getAge(){
  24.                 return age;
  25.         }
  26. }
  27. class StudentDemo{
  28.         public static void main(String[] args){
  29.                 //使用set方法赋值
  30.                 Student s1 = new Student();
  31.                 s1.setName("张三");
  32.                 s1.setAge(18);
  33.                 s1.study();
  34.                 System.out.println("-----");
  35.                 //使用构造方法赋值
  36.                 Student s2 = new Student("李四", 20);
  37.                 s2.study();
  38.         }
  39. }
复制代码

四、创建一个对象的步骤
        同第六天
五、static关键字
        方法区里边有一个静态区,可以放静态变量和静态方法,static数据就放在方法区
        静态的东西随着类的加载而加载
        优先于对象存在
        静态变量可以被公用
        如果一个变量需要被对象共享,就应该使用static关键字
        直接通过类名调用,最开始学习方法的时候都是用的static修饰
        静态只能调用静态
        静态变量和成员变量的区别
        静态变量属于类,随着类的加载而加载
        成员变量属于对象,随着对象的创建而加载
        静态变量存储在方法区中的静态区
        成员变量存储在堆内存
        静态变量优先于成员变量,所以不能用对象.来调用静态变量
六、main方法
        public static void main(String []){}
        public : 公共的,权限最大的
        static : 静态的,通过类名.直接调用
        void :没有返回值的
        main :一个被特殊化的方法名,如果写错,java虚拟机不会启动
        String[] args :字符串数组类型的参数,以前用于接收键盘录入
        在控制台输入 java 类名.java 数据1 数据2 数据3 ...
        会传入字符串类型的参数
        可以通过以下代码获得args的内存地址
  1. class Demo{
  2.                 public static void main(String[] args){
  3.                         System.out.println(args);
  4.                 }
  5.         }
复制代码
七、Api文档
  1. /**
  2.          * 当前类是可以对数组做常见操作的类
  3.          *
  4.          * @author
  5.          * @version
  6.          */
  7.         public class ArrayTool {
  8.                 private ArrayTool() {}
  9.         /**
  10.          * 遍历数组中的每个元素,显示出来
  11.          * @param arr 请传入一个数组
  12.          */
  13.                 public static void print(int[] arr) {
  14.                         ...
  15.                 }

  16.         /**
  17.          * 判断num数字是否存在数组arr中,返回它的下标位置
  18.          * @param arr 请传递一个数组
  19.          * @param num 请传入一个数字
  20.          * @return -1、没有找到,否则返回下标值
  21.          */
  22.                 public static int getIndex(int[] arr, int num) {
  23.                         ...
  24.                 }
  25.         }
复制代码
       使用 javadoc -d .\帮助文档 -author -version ArrayTool.java 可以创建帮助文档
        打开新建的帮助文档文件夹,找到 index.html 就是帮助文档
        通过Api查看Math方法,Math方法的父类是java.lang,所以不用导包,因为lang包里的方法会经常被用到
        基本的数学方法都可以在Math类中找到
        Math没有构造,都是静态成员和方法,直接用Math.调用
        学习Math类中的random随机数方法(大于0小于1)
       获得1-100之间的随机数的代码
  1. import java.util.Scanner;

  2. class GuessGame{
  3.         public static void main(String[] args){
  4.                 //使用Math类中的random方法
  5.                 //random方法返回的是double类型,需要强制转换
  6.                 int randomNum = (int)(Math.random()*100)+1;
  7.                 Scanner sc = new Scanner(System.in);
  8.                 //人机交互
  9.                 System.out.println("请输入你猜的数字(1-100)");
  10.                 //因为不知道循环次数,所以使用while循环
  11.                 while(true){
  12.                         int guessNum = sc.nextInt();
  13.                         if(guessNum > randomNum){
  14.                                 System.out.println("大了,请重猜");
  15.                         }else if(guessNum < randomNum){
  16.                                 System.out.println("小了,请重猜");
  17.                         }else{
  18.                                 System.out.println("恭喜,猜对了");
  19.                                 break;
  20.                         }
  21.                 }
  22.                 System.out.println("游戏结束!");

  23.         }
  24. }
复制代码
       附上第七天ppt和总结


day_07.rar

367.89 KB, 下载次数: 123

回复 使用道具 举报
总结的很不错,值得学习
回复 使用道具 举报
马赛 来自手机 中级黑马 2015-12-1 12:19:11
18#
上午继承里边的构造方法有点晕
回复 使用道具 举报
恩 不错不错~~~~
回复 使用道具 举报
感谢楼主
回复 使用道具 举报
12下一页
您需要登录后才可以回帖 登录 | 加入黑马