毕向东java教学视频跟踪笔记（写写帮推荐）

第一篇：毕向东java教学视频跟踪笔记（写写帮推荐）

1.java面向对象

1.1静态关键字static 用法：

是一个修饰符，用于修饰成员（成员变量，成员函数），当成员被Static修饰后，就多了一种调用方式，除了可以被对象调用外，还可以直接被类名调用(类名.静态成员）；

特点：

1.随着类的加载而加载

也就是说：静态会随着类的消失而消失，说明它的生命周期最长； 2.优先于对象而存在

明确一点：静态是先存在的，对象是后存在的； 3.被所有对象所共享

4.可以直接被类名所调用

.实例变量与类变量的区别：

1.存在位置

类变量随着类的加载而存在存在于方法区中 实例变量随着对象的建立而存在于堆内存中 2.生命周期

类变量生命周期最长，随着类的消失而消失 实例变量随着对象的消失而消失

静态使用注意事项

1.静态方法只能访问静态成员，非静态方法既可以访问静态又可以访问非静态；

2.静态方法中不可以定义this、super关键字，因为静态优先于对象存在，所以静态方法中不可以出现this； 3.主函数是静态的；

静态有利有弊

利处：对对象的共享数据进行单独空间的存储，节省空间，没有必要每一个对象都存储一份，可以直接被类名调用

弊端：生命周期过长，访问出现局限性（静态虽好，但只能访问静态）

什么时候使用静态

帮助文档制作

静态的应用

静态代码块

Jvm新建对象做了哪些操作

1.2设计模式

代码实现：

饿汉式：

记录原则：开发时，建议使用饿汉式

1.3继承

注意：不能因为要使用其他类的功能，简化代码而继承； 必须是类之间有所属关系才可以继承，所属关系为is a;

Java语言中：类关系只支持单继承，不支持多继承，只有在接口与接口之间才支持多继承，因为存在安全隐患：当多个父类中定义了相同功能，但功能内容不同时，子类对象不确定要执行哪一个；而接口中因为没有方法体而支持多继承避免了这种安全隐患；C++支持，但是java保留这种机制，并用另一种方式来实现（多实现）； Java支持多层继承：也就是一个继承体系 如何使用继承体系中的功能呢？

想要使用体系，先查阅体系父类的描述，因为父类中定义了该体系中共性的功能，通过了解共性功能，就可以知道该体系中的基本功能；那么这个体系就基本可以使用了。那么在具体调用时，要创建最子类的对象，为什么？ ① 因为父类对象有可能不能创建对象；

② 创建子类对象可以使用更多的功能，包括基本的和特有的； 简单一句话：查阅父类功能，创建子类使用功能

Java中除了继承关系外，还有聚集，聚合，组合关系； 继承关系：类与类之间，接口与接口之间（支持多继承）实现关系：类与接口之间

子父类中变量关键字this和super的使用：

子父类中函数关系：

子父类中的构造函数：

final关键字

抽象类：

抽象类实例：

1.4模块方法模块：

以下代码中：

关键字final是让确定的getTime()方法不被子类继承，而不确定的部分则抽象在runcode()方法中暴露出去让子类去实现；

注意：runcode（）方法不一定都定义为抽象方法，因为模板有默认的实现存在

1.5接口

接口可以被类多实现，这也是java类多继承不支持的转换形式，java支持多实现； 注意：接口因为没有方法体而支持多继承，类可以继承类又实现接口； 例：class C extends B implements A 接口的特点：

① 接口是对外暴露的规则 ② 接口是程序的功能扩展 ③ 接口是可以多实现的

④ 类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口 ⑤ 接口与接口之间可以有继承关系，并且支持多继承

1.6多态

定义：可以理解为事物存在的多种体现形态 人：男人，女人 动物：猫，狗 猫 x=new 猫（）； 动物 x=new 猫（）； 1.多态的体现

父类的引用指向于自己的子类对象 父类的引用也可以接收自己的子类对象 2.多态的前提

必须是类与类之间有关系，要么继承，要么实现 通常还有一个前提 存在覆盖 3.多态的好处

大大提高了程序的扩展性 4.多态的弊端

提高了扩展性，但是只能使用父类的引用访问父类中的成员 5.多态的应用

6.多态的出现代码中的特点

注意创建对象时：静态——》静态绑定

非静态——》动态绑定

1.7 Object类

定义：所有对象的直接或者间接父类，传说中的上帝。

该类中定义了所有对象都具备的功能；

Object中已经提供了对对象是否相同的比较方法；

如果自定义中也有比较相同的功能，没有必要重新定义，只要沿袭父类中的功能，建立自己特有的比较内容即可。

1.8内部类

存在没有父类和接口的匿名内部类吗？答案是肯定的，还有一个所有类的父类Object类：

1.8 异常机制

异常—finally代码块：

1.9 包package 对类文件进行分类管理。

给类提供多层命名空间。写在程序文件的第一行。类名的全称是 包名.类名。包也是一种封装形式。

Import关键字：

为了简化类名的书写，使用一个关键字，import.Import 导入的是包中的类。

建议，不要写通配符*，需要用到包中的哪个类，就导入哪个类。Jar包： 多线程

2.1相关定义

进程：是一个正在执行的程序；

每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。线程：就是进程中一个独立的控制单元。

线程控制着进程的执行。

一个进程至少有一个线程。

Java VM启动的时候会有一个进程java.exe.该进程至少有一个线程负责java程序的执行。而且这个线程运行的代码存在于main方法中。该线程称之为主线程。

扩展：其实更细节说明jvm，jvm启动不止一个线程，还负责垃圾回收机制的线程。否则将会导致主程序执行一段之后又返回回收垃圾，从而导致程序中止，所以jvm是一个多线程。

2.2如何在自定义的代码中，自定义一个线程？

通过对API的查找，java已经提供了对线程这类事物的描述。就Thread类。创建线程的第一种方式：继承Thread类。

2.3为什么要覆盖run方法呢？

线程运行状态：

/* 简单的买票程序，多个窗口同时卖票 */

class Ticket extends Thread { private static int tick=100;public void run(){ while(true){

if(tick>0)

System.out.println(Thread.currentThread().getName()+“sale: ”+tick--);} } }

class TicketDemo { public static void main(String[] args){ Ticket t1=new Ticket();Ticket t2=new Ticket();Ticket t3=new Ticket();Ticket t4=new Ticket();t1.start();t2.start();t3.start();t4.start();} }

class Ticket implements Runnable//extends Thread { private /*static*/ int tick=100;public void run(){ while(true){

if(tick>0)

System.out.println(Thread.currentThread().getName()+“sale: ”+tick--);} } }

class TicketDemo { public static void main(String[] args){ Ticket t=new Ticket();Thread t1=new Thread(t);t1.start();/* Ticket t1=new Ticket();Ticket t2=new Ticket();Ticket t3=new Ticket();Ticket t4=new Ticket();t1.start();t2.start();t3.start();t4.start();*/ } }

2.4线程间通信

第二篇：毕向东老师JavaSE基础视频08笔记上

一:数据工具对象的建立: 最初:代码写在main中

第二阶段:升级到函数中.可以复用.第三阶段:为了让另外一个类,能调用某函数,用类进行封装.二:数组工具中静态方法的使用.: 函数是否是静态的:只看一点就是是否访问对象的特有数据.这样要调用这个方法,不用创建对象,否则浪费空间.则把构造函数设置为private.三:数据工具类—文旦注释.文档注释中有一些关键词也是能被直接提取:@开头

要进行文档化,则类修饰必须用public,用javadoc提取之后变成这样了.classpath设置了之后只在当前的classpath中查找,不会去当前目录查找,除非当前目录也设置在其中./** */ 四:设计模式:对问题行之有效的解决方式,其实他是一种思想,java模式有23中基本.1:单例设计模式

解决的问题:就是可以保证一个类中在内存中的对象的唯一性.如果都设置成静态,在变量多的时候就生命周期过长导致浪费.例如:对于多个程序使用同一个配置信息的对象时,就需要保证该对象的唯一性.如何保证对象的唯一性饿方法,? 1:不允许其他程序用new创建该类对象.2:在该类中创建一个本类实例.3:对外提供一个方法,让其他程序可以获取该对象.步骤: 1:private修饰构造方法.私有化每个.2:通过new在本类中创建一个本类对象.3:定义一个共有的方法,将创建的对象返回.(可控,直接通过.变量名来操作则不可控)

现在要保证text对象的唯一性.加入三步骤,并改一下主函数的方法.五:单例设计模式图解: 第一步:加载了类.六:单例设计模式懒汉式

之前第一种方法,一加载就马上建立对象,恶汉式

但是这种方法是只有调用getInstance方法时才会创建对象,称之为单例设计模式的延迟加载模式.但是如果被多线程操作时存在安全隐患.面试懒汉式,开发多用恶汉式.

第三篇：java学习笔记

jdk(java development kit)

有如下公司或组织开发jdk

sun jdk

ibm jdk

bea jrocket

gun jdk

其中ibm的jdk包含的jvm（java virtual machine）运行效率要比sun jdk包含的jvm高出许多。而专门运行在x86平台的jrocket在服务端运行效率也要比sun jdk好很多。但不管怎么说，我们还是需要先把sun jdk掌握好。

1、jdk的下载和安装

jdk又叫做j2se（java2 sdk standard edition），可以从sun的java网站上下载到，http://java.sun.com/j2se/downloads.html，jdk当前最新的版本是j2sdk1.4.2，建议下载该版本的jdk，下载页面在这里：http://java.sun.com/j2se/1.4.2/download.html。

下载好的jdk是一个可执行安装程序，默认安装完毕后会在c:program filesjava目录下安装一套jre（供浏览器来使用），在c:j2sdk1.4.2下安装一套jdk（也包括一套jre）。然后我们需要在环境变量path的最前面增加java的路径c:j2sdk1.4.2bin。这样jdk就安装好了。

2、java documentation

java编程手册，java核心所在3、java 应用服务器

a、tomcat

b、ibm webshpere

c、bea weblogic

d、免费 jboss4、java应用的运行环境

应用服务器(app server)

app server是运行java企业组件的平台，构成了应用软件的主要运行环境。当前主流的app server是bea公司的weblogic server和ibm公司的websphere以及免费的jboss，选择其中一个进行学习就可以了，个人推荐weblogic，因为它的体系结构更加干净，开发和部署更加方便，是java企业软件开发人员首选的开发平台。下面简要介绍几种常用的app server：

1、tomcat

tomcat严格意义上并不是一个真正的app server，它只是一个可以支持运行serlvet/jsp的web容器，不过tomcat也扩展了一些app server的功能，如jndi，数据库连接池，用户事务处理等等。tomcat被非常广泛的应用在中小规模的java web应用中，因此本文做一点下载、安装和配置tomcat的介绍：

tomcat是apache组织下jakarta项目下的一个子项目，它的主网站是：http://jakarta.apache.org/tomcat/，tomcat最新版本是tomcat4.1.27，软件下载的连接是：http://

在启用这两个管理工具之前，先需要手工配置一下管理员用户和口令。用一个文本工具打开catalina_homeconftomcat-users.xml这个文件，加入如下几行：

这样用户“robbin”就具备了超级管理员权限。重新启动tomcat以后，你就可以使用该用户来登陆如上的两个管理工具，通过web方式进行tomcat的配置和管理了。

2、bea weblogic

weblogic可以到bea的网站上免费注册之后下载到最新的weblogic8.1企业版，license可以免费使用1年时间，其实这已经完全足够了。weblogic的下载连接：http://commerce.bea.com/index.jsp，.../edocs.bea.com/。

3、ibm webshpere

websphere同样可以下载到免费的试用版本，到ibm的developerworks网站可以看到websphere试用产品的下载和相关的websphere的资料，developerworks中文网站的连接是：http://。

4、jboss

jboss是免费开源的app server，可以免费的从jboss网站下载：http://，然...n.com/idea.html

四、java应用的运行环境

java的应用可以简单分为以下几个方面：

1、java的桌面应用

桌面应用一般仅仅需要jre的支持就足够了。

2、java web应用

java的web应用至少需要安装jdk和一个web容器（例如tomcat），以及一个多用户数据库，web应用至少分为三层：

browser层：浏览器显示用户页面

web层：运行servlet/jsp

db层：后端数据库，向java程序提供数据访问服务

3、java企业级应用

企业级应用比较复杂，可以扩展到n层，最简单情况会分为4层：

browser层：浏览器显示用户页面

client层：java客户端图形程序（或者嵌入式设备的程序）直接和web层或者ejb层交互

web层：运行servlet/jsp

ejb层：运行ejb，完成业务逻辑运算

db层：后端数据库，向java程序提供数据访问服务

4、java嵌入式应用

java嵌入式应用是一个方兴未艾的领域，从事嵌入式开发，需要从sun下载j2me开发包，j2me包含了嵌入式设备专用虚拟机kvm，和普通的jdk中包含的jvm有所不同。另外还需要到特定的嵌入式厂商那里下载模拟器。

第四篇：java学习心得笔记

j2ee学习笔记

注：框架可以用word菜单中的 “视图/文档结构图” 看到

j2ee模式

value object(值对象)用于把数据从某个对象/层传递到其他对象/层的任意java对象。

通常不包含任何业务方法。

也许设计有公共属性，或者提供可以获取属性值的get方法。

jsp

1．jsp的基础知识

__

_____ |directive(指令)

| |--scripting（脚本）

jsp-------| |__ action（动作）

|

|_____template data ：除jsp语法外，jsp引擎不能解读的东西

1）在jsp中使用的directive(指令)主要有三个：

a)page指令

b)include指令

c)taglib指令

在jsp的任何地方，以任何顺序，一个页面可以包含任意数量的page指令

2)scripting（脚本）包括三种类型

a)<%！declaraction%>;

b)<%scriptlet %>;

c)<%= expression%>;

3)action（动作）

标准的动作类型有：

a);

b);

d);

e);

f);

g);

h);

1.注释： <%-----jsp comment-------%>;

数组名arr[0]，第二个元素[1];c)二维数组的 长度 由”[ 几行 ]“确定！

d)定义方式2：类型[ ][ ] 变量名 = new 类型[ 几行 ][ ];//行数确定，列数不确定——每行可以随便 赋值。

e)定义方式3：类型[ ][ ] 变量名 = { { ,...,...,...}，{ }，{ }，......} //这种行数、列数都不确定。大括号 内的每个 大括号 代表 一行 的元素，每行有多少个元素 取决于 内大括号 中元素的个数。

19、面向对象的特点：封装性、继承性、多态性。

20、在创建变量后，JVM运行程序时，会自动初始化变量。引用型变量 为 null。

21、垃圾对象——没有变量引用的对象。

22、类的封装：将类中的属性 私有化。外界访问私有属性时 只能通过该属性的 getxxx（）方法。

a)//择Generate getter and setter--> 自动生成

set和get方法。

23、构造方法：实例化对象。

a)可以用 带参数的构造方法 在实例化对象时就 给私有属性 赋值。b)好的程序员 应该为每个类 写一个 无参构造方法。c)定义构造方法的条件：

i.方法名与类名相同。ii.没有返回值的 声明。

iii.方法中 不能有return 返回值。

24、this关键字

a)this指代 该类实例化的 对象。所以可以用 this.xx的方式调用 成员。b)在成员方法中使用this关键字，避免参数名与属性名相同。c)用this关键字调用 构造方法

i.只能在构造方法中 用this调用其他构造方法； ii.此时this语句必须位于第1行，并且只能出现一次 iii.不能在一个类的两个构造方法中互相调用。

25、static关键字

a)静态变量：

i.用static修饰的变量 ii.静态变量被所有实例共享

iii.可以使用“类名.变量名”的形式来访问。iv.只能修饰 成员变量 b)静态方法

i.希望在不创建对象的情况下也能条用 类中的 某个方法，那就用static关键字休息这个方法 ii.静态方法 只能访问 静态成员！

//因为非静态成员 必须先创建对象才能访问，而静态方法在被调用的时候可以 不创建对象——那么就没有非静态成员可供访用。

c)静态代码块

i.当类被加载时，静态代码会执行一次。而类只会被加载一次，所以静态代码块只会被执行一次。

ii.通常会用静态代码块对类的成员变量进行初始化。d)单例模式

i.private static 类名 INSTANCE = new 类名();量——自己创建一个对象。private 类名(){};

//私有的 构造方法，只能内部访问

}

//私有成员变public static 类名 getInstance(){ return INSTANCE;//定义静态方法，返回自己的实例对象。ii.第二种单例模式创建方法。

1.Private 类名(){} 调用。

2.public static fianl 类名 INSTANCE = new 类名();的不能被修改的 静态成员对象。

26、内部类——定义在类里面的 类

a)成员内部类

i.相当于成员方法，可以访问外部类的所有成员；

ii.因为成员内部类相当于 成员方法，所以想要创建内部类对象时，必须得用外部类的对象 去创建内部类对象：

1.外部类名.内部类名 变量名 = new 外部类名().new 内部类名();b)静态内部类

i.用static修饰的成员内部类，也相当于静态方法。只能访问外部类的静态成员。

ii.因为静态，所以在创建内部类对象时，可以不用先创建外部类对象：

1.外部类名.内部类名 变量名 = new 外部类名.内部类名();iii.静态内部类中 可以定义静态成员，非静态内部类则不可。c)方法内部类

i.在方法中定义的类，只能在当前方法中被使用。

27、当一个对象被当成垃圾从内存中释放时，它的 finalize（）方法会被自动调用。

//公有

//私有的 构造方法，只能在类的内部被

28、继承

a)继承关键字：extends。b)格式：Class A extends B{} c)单继承——一个类只能有一个直接父类。

29、重写父类方法

a)条件：方法名、参数、返回值类型 3个都相同。

b)重写之后，子类调用被重写的方法时，就是调用自己写的方法。c)重写应用：

i.应用对象 是父类的 公有方法。重载 应用的对象是 类本身的 方法。ii.重写父类 不适合子类的 方法 iii.实现接口。

30、super关键字

a)调用父类成员变量和成员方法：

i.super.成员变量;ii.super.成员方法（参数1,参数2,...）;b)调用父类的构造方法

i.super（参数1,参数2,...）;ii.必须位于子类的构造方法的第一行，且只能出现一次。

iii.在实例化子类时，系统会在 子类的构造方法中 调用

父类的构造方法——如果子类的构造方法中 没有调用 父类的构造方法，系统会自动调用父类的无参构造方法。所以 每个类的 无参构造方法 一定不要漏了！子类也可以显示的调用 父类的有参或无参构造法方法。c)解决 重写了父类方法之后，不能调用父类方法的问题。

31、final关键字

a)final修饰的类 不能被继承 b)final修饰的方法 不能被子类重写

c)final修饰的变量 是常量，不能被修改，且必须在定义时 为变量赋值。

32、抽象类

a)关键字 abstract b)抽象方法：abstract void shout（）{}；——没有方法体。

c)包含抽象方法的类必须声明为 abstract类：abstract class Animal{} d)抽象类可以 不包含任何抽象方法，只需用abstract修饰。e)抽象方法不能直接实例化，只能让 子类实例化。

33、接口

a)定义关键字：interface——interface Animal{} b)接口中的方法 被默认修饰为：public abstract——抽象方法。c)接口中的变量 被默认修饰为 :public static final —— 全局常量

i.所以变量最好用

全大写

表示。

d)因为方法都是抽象的，所以必须定义一个类 来实现（implements）接口——Class A implements B{} e)接口之间可以继承——interface C extends B{} f)一个类可以实现多个接口，接口直接间用逗号隔开。g)一个类可以在继承一个类的同时，实现其它的接口。

h)如果一个类去实现接口的话，那么这个类必须实现接口中所有的方法。

34、多态

a)方法上的多态

i.类内部方法的重载 ii.子类对父类方法的重写 b)对象上的多态性

i.假设父类：A；子类B B b = new B();ii.对象的自动向上转型：A a = b;//子类对象，变成了父类对象。

1.虽然a指向A的对象，但是如果B重写了A的方法，那a调用的还是B中的方法。

iii.对象的强制向下转型

1.若 A a = new A();2.B b =(B)a;

//父类对象变成了 子类对象。3.这时对象b调用的是 子类的重写的方法。

4.注意：对象发生强制向下转型之前，必须保证已经发生了向上转型，否则会出异常。

35、异常

a)异常类分为：编译时异常、运行时异常 b)异常处理机制： i.try...catch...finally 1.try代码包含可能发生异常的Java语句，catch块中包含针对一场进行处理的代码。

2.当发生异常时，系统将异常信息封装成一个异常对象传递给catch代码块。所以catch需要定义1个对应的异常类 变量。3.finally代码块包含，无论发生什么异常都要执行的代码。常用于关闭系统资源。

ii.throws关键字声明抛出异常，调用者对其处理。这种方法能通过编译，但是发生异常后就会终止运行。

c)自定义异常

i.首先定义 一个继承Exception异常的 异常类；异常类中 编写一个无参构造方法（调用父类无参构造方法），再编写一个 带String参数的构造方法（也调用父类的带Stirng参数的构造方法）。ii.再定义一个 测试类，定义要调用的方法，并在此方法后面用 throws关键字 声明抛出自定义异常；再在 方法体 内判断什么时候 用throw new 自定义异常（“要打印的信息”）。//声明自定义异常对象。

iii.最后在 测试类的main 方法中，iv.try{...}

catch(...){ System.out.printlan(e.getMessage)}

finally{...}

36、线程的创建： a)继承Thread类，并重写run（）方法。然后new Thread（）.start;开启线程。

b)实现Runnable接口，重写run（）方法。然后new Thread（new myRunnable）.start开启线程。

37、两种实现多线程的比较——实现Runnable接口的方法更好

a)可以让多个线程共享资源。——售票系统需要。b)避免单继承。38、36、