a371166028 发表于 2014-12-23 15:17
同醉....哈哈哈~~ 语文学不好,体育老师也笑死!

{:2_31:} 语文老师是体育老师教的，笑不出来。

2014.12.22-2014.12.23前两天偷懒了。
总结：
什么是面向对象
        是基于面向过程的。面向过程是基于函数的，强调的是实现对象的过程。而面向对象则基于对象，注重的是结果
        比如说，我面前有瓶饮料，我需要知道他的味道。
                        从过程来说，我需要打开，喝一下才知道味道。
                        而面向对象，看封面的说明就能知道味道了。
                        ---好吧，我也不知道我这样理解算不算对。就相当于消费者与商家。
        特点：更符合人的思维方式，将复杂的事情简单化，将人从执行者变为指挥者。
        类：成员变量（事物属性） 成员方法（事物的行为）
        对象：实例化的事物。
封装
        private 是封装的一种。提高代码的安全性。需要提供特定的方式才能调用。set和get，super-this
        (加载在栈内存)this:  this.成员变量 this.成员方法 this构造函数。
构造方法
        作用：给对象初始化。特点：没有具体的返回类型，没有具体的返回值，方法名必须与类名一致。
        注意：系统一般会默认给出一个无参的构造函数。如果你写了一个带参构造函数，那么请在前面手动添加一个无参的。
        构造方法重载：构造方法接受不同参数列表。 同方法重载。
继承
        当类a与类b有许多相互能通用的成员变量与方法时，那么就用继承。继承只能单继承而不能多继承，有多层继承。
        继承中构造方法的权限：子类大于或者等于父类。
        通过继承我们可以使用父类非私有的成员变量与方法。
        优点：提高了代码的复用性。让类与类有了关系。
        子类调用父类成员时用(加载在堆内存)super:  super.成员变量  super.成员方法  super构造函数。
static（静态）：
        当被static定义时，只能被static方法调用。静态方法块随类加载而加载。生命周期最长。只加载一次。
重写
        子类与父类出现相同成员方法时(方法名 返回类型 参数都相同)。

内存图
          先将class Person加载到方法区的代码区，加载main()到栈。
          然后Static s,加载到main内存下。Son类发现extends加载Person1。
          加载Person1类Static到静态区再加载Son中Static。(加载时会先加载成员变量。)
          new 在堆开辟内存空间。Son 然后加载Son。默认super到父类。
          在Son中开辟小块内存给Person1。
          加载父类中的成员,完成后回到Student加载Student成员。

          顺序：加载成员变量父类中Static方法-子类中Static方法-父类中代码块-父类构造函数
                        -父类成员方法-子类代码块-子类构造函数-子类方法。

                今天实在是学晕了。先写这么多了。后面记不大清楚了。第二天补上了。
                有BUG希望各位补充。          

2012.12.24
static(补充)
                (静态代码块)只加载一次。
                被所有对象共享。
                可以通过类名.调用
重载(overload)
        在同类中，方法名相同，参数列表不同。
重写(override)
        只存在于继承关系中。
        子类与父类中，方法名，参数列表相同。无具体返回值，返回类型。
        重写时在子类中添加新执行体+super.方法名。就能同时保留子父类的执行体。
final
        相当于被定死刑一样。
        被final定义的变量：变为常量，不能被修改。
        被final定义的方法：不能被重写。
        被final定义的类：不能被继承。
单例模式
        私有化构造函数(private 构造函数)
        在类中创建一个本类对象
        提供一个方法能够访问。
        理解：
        设置一个static的构造函数，在加载时就存在于方法区，加载时创建一个静态对象(不会再次创建)
        当再创建新对象时直接使用这个静态对象，而不用重新再堆内存中重新创建一个对象
       
        今天主要还是复习。

我是按着课件那个来写的，各位圣诞节快乐！

总结：
1.多态的概念和前提
        概念：对象在不同时刻表现出不同的形态。
        前提：要有继承关系，要有重写，父类引用子类对象。
2.多态的成员特点
        成员变量没有重写，成员方法有重写。
3.多态的弊端和好处
        弊端：父类不能引用子类特有的方法，需要先将父类转型为子类。
        好处：可扩展性和可维护性。
                类型转换：向上转型（小转大），向下转型(大转小)。
4.抽象类,抽象方法和接口的由来
        抽象方法：只抽取方法名，而不确定方法体。
        抽象类：因为有了抽象方法，所以必须用absract修饰。
        接口：一个类中全是抽象方法时，就没必要定义成一个类。将其定义为一个接口。
5.抽象类的基本特点和成员特点(关键字:abstract)
        基本特点:
                        抽象类不能被实例化。
                        有抽象方法的类一定要用abstract修饰。
                        继承抽象类时，子类必须将父类中的抽象方法复写，或者子类也用abstract修饰。
        成员特点；
                        成员变量:
                                成员变量可以直接被子类继承使用。
                        成员方法：
                                抽象类中有抽象方法，也可以有非抽象方法。
                        构造方法：
                                抽象类构造方法是不能被实例化的，所以抽象类构造方法的存在只为让子类创建对象时初始化父类。
6.接口的基本特点和成员特点(关键字 interface  implements)
        基本特点:
        成员特点：
                        只有成员变量与成员方法(因为成员变量被final修饰所以不能被改变也可以说是常量)
                        成员变量默认被pulbic static final修饰。
                        成员方法默认被pulbic abstract 修饰。
7.类与接口的关系
                        接口通过类来实现（格式；class 方法名 implements 接口名）
                        当类实现接口时，必须重写接口中的方法。
8.接口与抽象类的区别
        区别：
                接口：能被多继承，也能被单继承。
                          成员变量：可以是变量，也可以是常量。有构造方法。成员方法可以使抽象的也可以是非抽象的。
                抽象类：只能被单继承或者多层继承。
                          成员变量只能是常量，没有构造方法，成员方法只能是抽象类。
        抽象类中定义的是共性的内容(必须让子类跟从父类)，而接口则相当于对象的扩张(想用就用)

1.Java中包的概念
其实就是文件夹。区分相同名的类名。
2.带包的类的编译和运行
编译：javac -d . 类名.java  .表示当前路径
运行：java 带包路径.类名
3.不同包下类的使用和导包
使用：package 包名1.包名2.. 注意权限。建议都用public
导包：需要用import 包名1.包名2...类名
4.权限修饰符作用汇总
private   只能在当前类被访问
默认    当前类和同包下（没有关系的类或者子类)
protected  当前类，同包（没有关系的类或者子类)，不同包(子类)
public  在当前类，同包，不同包情况下都能被访问
5.修饰符使用位置汇总
static  能够修饰   成员变量和方法，成员内种类。
private 能够修饰   成员变量和方法，成员内中类，构造方法。
final   能够修饰   成员变量，类，成员方。
public  能顾修饰   所有。
abstract 修饰    成员方法，类。
6.内部类的定义和分类
定义：存在于类中的类。
成员内部类：想要访问局部内部类需要先创建对象。
局部内部类：能访问外部类的所有成员。访问局部变量不许用final修饰
7.内部类的特点和使用
成员内部类：想要访问局部内部类需要先创建对象。
局部内部类：能访问外部类的所有成员。访问局部变量不许用final修饰

8.匿名内部类的用法和使用场景
没有名字的局部内部类。需要存在一个类或者接口。  方法中没有名，有继承或者实现接口的子类。
使用： 遇到方法的形式参数是接口或者抽象类时

加油 加油

和宿舍，班里的人相处融洽，班上的人都不认识？这是什么情况？

2014.12.27
多线程笔记：
        要创建线程对象时先要明确要运行什么代码。
1.一个进程至少有一个线程，主线程从main方法开始执行。
2.继承thread类，
  复写run()方法：
  类型.start()开始执行。开启线程，调用Thread类中run()方法。
  class A extends Thread{
        public void run()
        {
        s.o.p();
        }
  }
  class C
  {
        public static void main(String[] args)
        {
        Thread t = new A();
        t.run();
        t.start();
        }
  }

3.多线程特性之一：随机性 谁抢到谁就执行，至于执行多长，看cpu咯。
4.Thread类用于描述线程 创建Thread对象==创建线程。
5.线程都有自己的名称：Thread-0 0开始，通过super自定义线程名称。
6.statuc thread currentThread():获取当前线程对象.
  getName():获取线程名称。 setName()或者构造函数:设置线程名称(意义：获取名称用于判断)
  局部变量在栈内存中都有自己独立的一份。

第二种创建线程方法：
        Runnable接口。
        步骤：
        1.定义类实现Runnable接口。
        2.覆盖Runnable接口中的run方法。
                将线程要运行的代码传入run()方法中。
        3.通过Thread类建立线程对象。
        4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
               
        5.调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

实现方式和继承方式区别
        实现方式可以继承。定义线程时最好用实现。

两种方式区别：
        继承Thread:线程代码存放在Thread子类的run方法中。
        实现Runnable：代码存放在接口子类run中
       
class A implements Runnable{
        public void run()
        {
        s.o.p("");
        }
  }
  class C
  {
        public static void main(String[] args)
        {
        Thread t = new Thread(a);
        A a=new A();
        a.run();
        a.start();
        }
  }

.Object：一切类直接或间接的继承了Object类(顶层)。
        toString()：返回对象的字符串表示形式。
        equals() :默认比较对象的内存地址
==：
        引用类型：比较对象的内存地址。
        基本类型：比较基本类型的值。
equals：
        引用类型：默认比较对象的内存地址。可以通过重写比较对象的规则

第二天将多线程看完，熟悉多线程并多敲毕老师给的的代码，尝试做几道面试题(做不来百度)

我也想去基础班,但是深圳3月份才开~

2014.12.28今天出了点小状况，就没把视频看完，觉得自己面向对象的三大特性理解运用不熟，又去看前面的了。
只看了同步代码块。今天就不发笔记什么的了。

理解Scanner录入数据出现的问题及解决方法
        当只创建一个Scanner对象的时候，nextInt()方法录入过后如果录String类型会出现录入为空的现象(不是null)
        解决办法：新建一个Scanner对象。  或者在String类型录入后面再加一条String类型录入
掌握String类常见构造方法
理解String常量池
        当使用String a ="abc"时  他会先去String常量池找abc 没有会在常量池建立一个abc。
        如果存在abc会直接引用这个abc的地址
掌握String类的常见判断方法
掌握String类的常见获取方法
部分掌握String类的常见转换方法
部分掌握String类的其他常用方法
练习使用断点调试

今天因为开晚会要表演节目 表示String掌握的不是很牢固 代码只敲了一次 睡觉了。

好吧 今天晚上做作业突发奇想 ，然后就不能自己的写了个增查的名单录入DOS版。集合刚开始学，代码比较繁琐基础 勿喷- -。import java.util.Scanner;

1. import java.util.Scanner;
   
2. 
   
3. public class Students {
   
4.         private static Scanner sc;
   
5.         public static void main(String[] args) {
   
6.                 //提示
   
7.                 System.out.println("提示：输入read可以查看录入人数\n输入stop可以停止输入");
   
8.                 int stemp = 0;
   
9.                 //建立一个长度为5 的学生类数组 StringBuffer类型的。
   
10.                 String[] student =new String[500];
    
11.                 for (int i = 0;i<500;i++)
    
12.                 {
    
13.                         System.out.println("请输入(先名字再年龄): ");
    
14.                         sc = new Scanner(System.in);
    
15.                         //输入名字
    
16.                         String name = sc.nextLine();
    
17.                         //输入年龄.
    
18.                         String age = sc.nextLine();
    
19.                         if(name.equals("read"))
    
20.                         {
    
21.                                 bianLi(student,stemp);
    
22.                         continue;
    
23. /*                        else if(age.toString()=="stop")
    
24.                                 bianLi(student);*/
    
25.                         }
    
26.                         else if(name.equals("stop"))
    
27.                         {
    
28.                                 bianLi(student,stemp);
    
29.                                 System.out.println("感谢使用");
    
30.                                 break;
    
31.                         }
    
32.                         else
    
33.                         {
    
34.                                 // 建立一个String类型存储变量，将名字和年龄存储进去。
    
35.                                 String st =name+" "+age;
    
36.                                 student[stemp] = st;
    
37.                                 stemp++;
    
38.                         }
    
39.                 }
    
40. 
    
41.         }
    
42.         public static void bianLi(String[] arr,int stemp)
    
43.         {
    
44.                 for (int i = 0; i <stemp; i++) {
    
45.        
    
46.                                 System.out.println("学生名单："+arr[i]);
    
47.                 }
    
48.         }
    
49. }
    

复制代码

最重要的是我今晚我什么都没干 就弄这个弄了半天:@ 太浪费时间了

呵呵 我就到此一游

jiayou ba ha a

加油！我们在同一路上，我在努力自学

真是个记笔记的好方式，楼主聪明哦

厉害

给力啊，大家一起努力吧。

继续加油！