java 课堂总笔记

课程内容:
android 应用开发
1.java编程
2.android应用编程

windce miniGUI QT.... 
好看的用户界面

android 系统框架组成

android=linux c+java 混合体
android 应用开发入口是java

android 学习涉及到编程语言:
c
c++
java

java编程

高司令 golsing 在sun 95年创建java,被oracle 甲骨文收购。
特点:
1.开源
2.编译一次 到处运行。 跨平台
3.具有编译和解释型
java平台
1.java se    J2SE  标准版   初学从这里开始
2.java ee   J2EE   企业版   web开发    服务器上运行的程序    云计算大数据
3.java me  J2ME 微型版   嵌入开发



J2SE搭建开发环境
1.下载windows版的JDK
2.装jdk  运行java命令 ok
装的目录有:
bin子目录:各种java命令工具
    java   启动虚拟机加载类的命令
    javac 编译器

3.设置环境变量  运行javac命令 ok





java 类分为
1.属性  全局变量
2.方法  函数

windows 终端命令
1.dir   类似  ls
2.cd   类似 cd
3.切换盘符到e盘    c:\>e: 

JVM:java虚拟机
JRE=JVM+类库   java运行时环境
JDK=JRE+工具命令

运行java程序的步骤:
1.编写java源程序保存到  .java文件中
2.编译java源文件
javac Test.java    生成  Test.class 文件  2进制文件  也叫 字节码文件 不能操作系统上运行
放在java 虚拟机(JVM)上运行
3. java Test  //用java命令启动JVM加载一个名为Test的类 调用特殊的main方法启动程序


java语法 
0.java是面向对象的编程语言   
1.属于c语系,强类型语言
2.数据类型
分为两类
基本类型:
int  short long    int 4个字节
char 2个字节 unicode编码
void
float double
byte 1个字节
boolean  true|false

while(true){}

java没有指针

基本类型可直接用运算符来运算.  + - * / || && ! >=....
基本类型不是对象,但是考虑到效率保留

但是引用类型不能直接运算的,可以绑定对象的方法和属性才能运算.

引用类型(全部是对象)
    类   String 类
    数组
    接口

java哲学思想:万物皆对象

类和对象

类是抽象的 设计图纸
c:
struct  A
{
    int a;
    函数指针 foo;
}
A var1; 
var1是变量(对象)  A类




对象是具体的  按设计图纸生产产品 也叫实例

class 人类
{
    //属性 :静态特征
    int age;
    boolean gender;//man:true woman:false;
    String name;

    //方法:动态行为

    void sleep(){}
    void eat(){}
    void drink(){}
    void useLanguage(){}
    void useTool(){}
}

人类  小花=new 人类();//1.声明一个小花的变量名,类型为人类 2.new 创建一个人类的对象
人类  小芳=小花;//小芳就是小花所代表的那个对象
//3.将该对象的引用赋值给小花变量
小花.age=18;
小花.name="花花";
小花.gender=false;//属性
小花.eat();
小花.drink();
小花.sleep();//方法
. 运算符  对象可使用.运算符绑定属性和方法


写java程序干两件事情:
1.创建对象,需要找到类(系统提供的类 String 类 或 自定义类),用该类创建对象
2.给java程序中各种对象发送消息  对象.方法()


解决吃凉瓜排骨
c程序:逐步求精,步骤分解...问题解决

java程序:找服务员对象,发消息点菜,服务员找厨师
找对象,给对象发消息过程


70年代 规模扩大 >10万 >1000万 搞失败  软件危机==> 软件工程方法学
人月神话 
人月不能互换,前提人不需要沟通.
项目=3人*2月=6人月=6人*1月=6人月
扛麻袋,写程序
业务逻辑  商业逻辑

采用面向对象


面向对象目标:可重用,可扩展,可维护
传统重用:算法,数据结构,代码复制粘贴
重用:业务逻辑上实现重用

面向对象的特点:
1.抽象封装
抽象:描述主要忽略次要.
封装:定义类提供接口



小结:
1.android 组成=linux c+java
2.java特点
3.java版本  
4.java se开发环境搭建
5.编写,编译,运行java程序步骤
6.java语法
基本类型
引用类型
7.类和对象

java 基本的IO

1.基本输出 (到显示器)
System.out 对象  类似c 的stdout 标准输出流
对象的有两种方法
System.out.println()  换行
System.out.print()  不换行
System.out.printf() 带变参

2.基本输入(键盘输入)
System.in 对象 类似c 的stdin 标准输入流
Scanner 类来实现 字符串和基本类型值的输入



java变量的默认值:
基本类型:
int long short : 0,0,0l
float double : 0.0f 0.0
byte,char :(byte)0,(char)0
boolean:false

引用类型: null


java api文档结构:
包1
java.lang 包(自动导入)
    String 类
        字段(属性)
        构造方法
        成员方法

    System 类

java.util包
    Scanner 类

包2


包3

包4


作业:
1.通过终端实现一个用户密码验证
username:xiaohua
password:xiaohei
welcome xiaohua!!
goodbye xxxxx!

"xiaohua".equals(usr)&&"xiaohei".equals(pwd)

2.做简易计算器  op只能是+,-,*,/
输入: op1  op  op2
11+99
回车输出
11+99=110

如何将字符串转变为整数?
"11+99" => "11"  "+"  "99"
int a=Integer.parseInt("11")

3.利用数组完成
请输入学生人数:4
输入分数:56
输入分数:56
输入分数:56
输入分数:56
分数为:56 56 56 56 56
平均:56.0

4.定义一个堆栈类

class Stack{
    int len;
    int a[];//不能写  int a[50];
    void push(int i){}
    int pop(){}
    Stack(int l ){
        len=l
        a[]=new int[len];
    }

}




Stack s1=new Stack(5);
Stack s1=new Stack(8);
for(int i=0;i<5;i++){
    s1.push(i);
}
for(int i=0;i<5;i++){
    s1.pop();
}

==========================
2day
java 对于引用类型 ==含义:比较对象的引用

String s="abc";
String s4="abc";
s==s4  =>true

String s2=new String("abc");
String s3=new String("abc");
s2==s3 =>false

java 基本类型转换

类型大  large;
类型小  small;
large=small; //自动
small=(类型小)large;

Integer 类

哲学:万物皆对象
java不是纯OOP
1.基本类型 int==> Integer 类 包装类  把基本类型的变量/值看成一个对象
short ==> Short
float Float
double Double

自动装箱/拆箱

2.静态 static 成员 


数组也是引用类型

int a[];    int[] a;
int[] a=new int[100];

String[] ss=new String[100];

int[] a={1,2,3};
int[] a=new int[]{1,2,3}

String[] ss={"11","22"};
记住:
java的数组对象自带一个属性: a.length
java的数组有边界检查(不准越界,否则异常终止)

java面向对象特点:
目标:可重用,可扩展

典型特征
1.抽象封装 =>定义类
2.继承
3.多态
4.接口
5.内部类

定义类可用的元素有哪些?
1.属性
2.方法
    构造方法
    成员方法
    重载方法:方法的重载要求 方法名相同,方法参数列表不同(类型不同,个数不同)

3.类成员(类的属性和方法)的访问修饰符
public 暴露成员  外部都可使用
private 隐藏成员 外部不可用
默认  包访问权限
protected

4.this 代表当前对象 自引用 可用来调用构造方法

5.static 成员

非静态成员  实例(对象)相关  对象.成员  this.成员  每个对象都有一份属性

静态成员  类相关  类.成员  静态属性只有一份,类所有
        静态方法只能调用静态方法和使用静态属性

6.包
避免类名冲突,采用操作系统中文件系统机制
包名 对应                   目录

com.robin.Test          当前目录/com/robin/Test.class  (每个类编译后都会生成class文件)

类全名=包名(com.robin 二级包)+类名(Test)

package 为类声明包  package p1; //必须放在第一行
import 为类导入包   import java.util.Scanner;






重用类: 
重用代码不是破坏现有程序,不重头代码.

组合:"有一个"
class Engine{
    void start(){}
         
}
class Car{
    Engine engineObj;
    void startCar(){
        engineObje.start();
    }

}

物种:分门别类 有层次结构 有序  无序  

继承:在现有的类的类型基础上添加一些代码,创建一个新类(形成一个层次结构)
子类可拥有父类的属性和方法
继承语义:"是一个"
java是单继承体系,java的类只能有一个父类
类 Object 是类层次结构的根类。每个类都使用 Object 作为超类
class A extends Object{
}
super 关键字
1.用super调用父类的构造方法,对super的调用必须是构造器中的第一个语句.
2.用super来调用父类的成员(属性,方法)

如果父类成员是 protected 允许子类在不同包内也是可访问的.

访问修饰符和类,对象之间的可见性分析
弱->强
private  默认  protected  public

多态  
打+东西:打结合不同的东西有不同的解释和结果.

    重载方法

    重写方法


java方法的绑定机制
绑定:将一个方法调用同一个方法的主体(对象,类)关联.
静态绑定:编译时决定绑定的方法 static private
动态绑定:程序运行时根据对象的类型来绑定方法 java大部分都是动态绑定.
在继承使用多态,可解除同一个父类下不同子类之间的耦合.(多态可解耦)

final 关键字
1. final 作用属性  常量   类似 const
final int ABC=100;
2. final 作用方法  该方法不能重写
3. final 作用类    该类不能有子类

抽象类
    java有两种类
        1.具体类:可实例化,可创建对象.
        2.抽象类:不能实例化,不能创建对象.用来继承可实现多态
abstract class A
{
    //一般有抽象方法
    abstract void foo(int a,String name);
}

通过抽象类的定义接口(抽象方法),来控制该抽象类下一系列子类的接口.

小结:
java 在引用类型中 "==" 含义
java 基本类型转换类似c
java 包装类  自动装箱/拆箱
java 数组
int[]  a;
String[] s;
a.length 数组长度,数组不能越界
java 类的定义
    属性
    方法
        构造方法
        成员方法
        重载方法
    静态成员
        静态属性
        静态方法
    访问修饰符(探讨 类的成员的可见性问题)
        private 类内部可见
        public  外部都可见
    this
    包
        声明包  package
        导入包  import

复用类:
组合 有一个

继承 是一个
    super

访问修饰符
    protected

多态
    在继承中实现多态的方法
    
抽象类
    通过抽象类的定义接口(抽象方法),来控制该抽象类下一系列子类的接口.

继承和多态,父类和子类的类型转换


作业:
1
Object类中有一个重要的方法是toString(),可返回一个字符串,代表对象的值.
一般所有子类都重写此方法,
现在定义一个Parent类,并再定义Parnet的子类Derived.
在这两个类中都重写toString()方法,
分别打印输出 “this is Parent toString().”和”this is Derived toString().”
最后定义一个主类UpCast,设计一个main()方法实现如下代码:
    Derived d=new Derived();
    System.out.println("Derived 的 toString():"+d);
    Parent p=(Parent)d;
    System.out.println("转换为parent类型的toString():"+p);
    Object o=(Object) d;
    System.out.println("转换为Object类型的toString():"+o);
请思考为什么运行结果是这样?


2 分析如下代码
abstract class Shape
{
    public abstract void draw();
}
class Circle extends Shape{
    public void draw(){
        System.out.println("draw a circle!");
    }
}

class Square extends Shape{
    public void draw(){
        System.out.println("draw a square!");
    }
}

class Triangle extends Shape{
    public void draw(){
        System.out.println("draw a triangle!");
    }
}
public class Shapes {
  public static void main(String[] args) {
    Object[] shapeList = {
      new Circle(),
      new Square(),
      new Triangle()
    };
    for(int i = 0; i < shapeList.length; i++)
      (shapeList[i]).draw();   
      
  }
}

指出哪里有错误?

3
利用抽象类实现模板模式,实现如下类:
1)
定义抽象类 AbstractDisplay
有如下方法
public abstract void open();    
public abstract void print();
public abstract void close();
public final void display(){ 
    open();
    for(int i=0;i<5;i++){
        print();
    }
    close();
    
}
2)定义两个具体类
CharDisplay
StringDisplay
3)定义如下主类Main
public class Main {
    public static void main(String[] args){
        AbstractDisplay o1=new CharDisplay('H');
        AbstractDisplay o2=new StringDisplay("hello,world.");
        AbstractDisplay o3=new StringDisplay("你好");
        o1.display();
        o2.display();
        o3.display();
        
        
    }
}
4)执行结果:
<>
+------------+
|hello,world.|
|hello,world.|
|hello,world.|
|hello,world.|
|hello,world.|
+------------+
+----+
|你好|
|你好|
|你好|
|你好|
|你好|
+----+
请分析编写代码的好处在哪里?


======================
3day

System.out.println(对象);==>最终 对象.toString()
    String.valueOf(对象)
        如果参数为 null,则字符串等于 "null";否则,返回 obj.toString() 的值。

引用类型转型                                                                              
    Human   obj                                     
    Boss    boss                                        
    obj=boss            向上转型  自动安全                          
                                            
    boss=obj   向下转型  不安全 强制转换                                       
                                            
    if(obj instanceof Boss)                                     
            boss=(Boss)obj;                             

oop设计模式
某个场景的一种最佳解决方案.
GoF 方法学大师  23种  
java c# c++ javascript....


面向对象
1.抽象封装
2.复用类
    组合
    继承
3.抽象类
4.接口 interface  

接口:
完全抽象的类变成了接口
特点:
1.接口中
定义的方法全部是抽象方法,不写也是 public  abstract 方法
定义的属性,不写也是 public static final 
2.用来描述某种抽象的行为,语义"像一个"
3.接口也可实现多态
4.接口具有多继承的特点  
一个类可实现任何接口以及任意多个接口  

记住:
子类或实现类重写父类的方法或接口的方法
不能将重写方法使用更低访问权限,可提升访问权限

5.内部类

class A//外部类
{
    int a;
    void foo(){}
    class B //非静态内部类
    {
        //A的成员都可见
        void foob(){
            
        }
    }
} 用的少

class A
{
    static B{//静态内部类
        //A的静态成员可见
    }
}
new A.B(); //创建B类的对象

到此为止 
java OOP基本语法
抽象封装
继承
抽象类
接口
内部类


============================
系统类库就是把 一堆.class文件打包 .jar文件 放在 jdk的lib目录下
自动导入

eclipse的使用  (IDE)
1.下载开源免费软件工具包 解压
必须先安装JDK,设置path环境变量
2.启动eclipse
3.创建一个java工程
file->new->java project

4.设置字体和补全功能

5.eclipse是自动编译
6.运行 run as->java application


7.导入工程
file->import->general->exist project

8.用javabean生成 getter/setter方法
右键->source->gerate getter and setter...
            gerate constructor using fields...


航班管理系统
用java做项目
高内聚低耦合

1.录入航班信息
2.删除航班信息
3.修改航班信息
4.查询所有航班信息
5.按航班号查询航班信息




项目组成 架构
三层
1.表现层 (展示数据,实现和用户交互)  界面层
字符界面 
GUI 窗口,手机界面,网页
com.robin.ui包 

2.业务层
实现逻辑处理
com.robin.biz包
3.持久层 (实现数据持久化存取)
文件
数据库
网络
com.robin.dao 包

4.值对象bean
com.robin.bean 包


java 集合框架也叫对象容器类/接口

1.用数组(也可做对象容器)存放对象   
不足:有边界检查,适合顺序读写 频繁增删   
Flight[] flights=new Flight[]
好处:操作简单,按下标访问,基本类型只能用数组操作

2. 对象容器这套类库具有层次结构  继承架构           
在java.util包,包含对象容器的类库
Collection 接口  描述对象容器操作的抽象方法
    List 接口  使用这些工具类的方法有
                add(E e) 将一个对象访问List容器
                E get(int index) 根据索引取出对象
                int size() 容器中对象数量
                E remove(int index) 
                boolean remove(Object o) 
                void clear() 
 

        ArrayList 实现具体类   俗称"动态数组"
        LinkedList 实现具体类      "链表"


    Set 接口
        HashSet  实现具体类  容器中不能有重复的元素

柜子 装xxx类型的柜子
衣柜
书柜
酒柜
鞋柜
柜子
柜子<衣>
柜子<书>

=================================
4day

对象容器/数组 有对应算法的工具类

数组对应的:Arrays 类  排序 查找 
此类包含用来操作数组(比如排序和搜索)的各种方法

对象容器对应的: Collections 类

public static > void sort(List list)
类型T必须是实现了Comparable接口的类型
由于String类:
public final class String extends Object implements 
Serializable, Comparable, CharSequence
实现Comparable接口所以可直接进行排序.

java IO 流
流:一维线性空间放的可传递的数据(水)
分类:
输入流 输出流
字节流 byte 1byte 字符流 char 2byte
节点流(低级流)  处理流(高级流)

流的处理的特点:
1.对称  分类是对称
2.装饰  把一种转换另一种流
装饰者模式设计
class A //节点流  水
{
}

class B //处理流   热水管
{
    B(A a){}
}

class C  //处理流  加coffe
//A类想用C,B,C+B的功能
{
    C(A a){}
}
A 是B,C类的父类

C c=new C(new A()) //A具有C的功能
C c=new C(new B(new A()));//A具有B,C的功能
B b=new B(new A());//A具有B的功能

字节流的根类
InputStream   OutputStream

read()          write()

一般很少直接使用字节流的.
文件字节流
FileInputStream   FileOutputStream


PrintStream 打印流  按系统默认字符编码GBK打印内容




java 异常
千万不要异常报告给用户!!!

分为两类
1.可检查异常:编译器在编译可检查要求异常处理
2.运行时异常:程序在运行时出现异常.

处理异常方法
try{

}catch(异常类型 e){

}finally{

}

异常继承架构

程序员可处理的异常有一个根类:Exception 

Exception  父类
    RuntimeException 子类  运行时异常的父类
        ArithmeticException
        NumberFormatException
        ArrayIndexOutOfBoundsException

   非RuntimeException 异常类 是可检查的异常.

InputStream 类有一个方法的声明, throws 异常声明 IOException
public abstract int read()
                  throws IOException

告诉调用者你调用read()方法时,可能会抛出 IOException 异常.
编译器强制你做异常处理


小结:
1.工具类  排序,查找等算法功能
针对数组  Arrays 类
针对对象容器 Collections 类

对象排序要求对象的类需要实现 Comparable 接口 重写 compareTo()方法

2.java IO
分类:
按字节/字符划分
按方向
低级流/高级流


标准IO:
System.out  还有  System.in   
用 Scanner scanner=new Scanner(System.in);
让System.in具有Scanner类的功能

字节流类的体系  
InputStream  OutputStream 根类
FileInputStream FileOutputStream 
PrintStream

文件IO 读写,复制

3. 异常
分类
可检查异常:编译器可检查,做异常处理或异常声明
运行时异常:编译器不可检查  都是来自于 RuntimeException 类及其子类

异常类的架构

Exception
    RuntimeException       不可检查
    非 RuntimeException 类  可检查

java方法定义
返回类 方法名(参数列表) throws 异常类

异常处理
try{
    //放监控的代码
}catch(异常类 e){
    //异常处理的代码 不要做业务处理
}finally{
    //资源释放
}

try必须有,catch,finally 可选


文本流 字符流
流以字符为单位(2个字节 char) 根据当前字符编码集转换处理
用途文本文件处理.

Reader          Writer
FileReader      FileWriter   文件字符流

InputStreamReader  OutputStreamWriter  字节转字符的字符流

BufferedReader      BufferedWriter  带缓冲区的字符流


System.in 字节流对象===>读出来文本信息


作业:
航班系统
要求:
0.航班排序查询
1.航班数据存放在文件中,通过读文件获得数据
2.添加航班信息写入文件
3.从文件中删除航班信息 (先读出来放在列表中再删除,然后再写入文件)
4.从文件中修改航班信息 (先读出来放在列表中再修改,然后再写入文件)

============================
5day
java
1.基本语法
2.面向对象实现
3.对象容器 泛型 集合框架
4.异常
5.IO 
6.项目 分层
7.线程
8.网络

java并发处理:基于线程来实现的
进程
线程

java的线程创建必须借助 Thread 类启动线程

JVM启动时会有多个线程在执行(main线程,垃圾回收GC线程...)
默认写java都运行在 main线程之上

Thread 类 常用方法
Thread() 
Thread(Runnable target) 
Thread(String name) 
Thread(Runnable target, String name) 
static Thread currentThread() //获取执行代码所在线程对象
void start() //启动线程
static void sleep(long millis) //执行代码会休眠/阻塞  时间到唤醒

创建线程的方法

方法1:
step1:定义一个继承Thread类的子类
step2:重写Thread类的run方法
step3:用该子类创建一个对象并调用该对象的start()启动线程

子类不需要继承任何其他父类,简单.

方法2:
step1:定义一个实现Runnable接口的实现类
step2:重写该接口的run方法
step3:用该实现类来创建一个对象,并用来初始化一个Thread类的对象
调用Thread对象的start()启动线程

实现类必须要继承其他父类

用户登录

用户密码掩码功能

Scanner scanner=new Scanner(System.in);
Sring pwd=scanner.next();//调用时不按回车 主线程阻塞
password:123
password:****  1.打印 backspace ascii控制字符 8   
               2.打印 掩码 '*'
                交给子线程来做

主线程+子线程 
1.什么时候启动线程
2.线程什么时候结束



控制线程的方法
1.  join() 方法 适合多个线程协调工作
2.  同步 synchronized 关键字



当多个线程同时操作一个共享对象时发生竞争状态(不同步状态).
上锁->操作->释放锁 
java的对象隐含"锁",也叫"同步监视器"用来保护共享对象内部状态不处在竞争状态.

同步
1.同步方法 //肯定会有一个对象绑定同步方法
当一个线程调用同步方法(拥有锁),其他线程想调用该方法必须等待,当锁的拥有者调用完毕退出
同步方法(释放锁),该方法可给其他等待的线程调用.

适合可修改源码

2.同步对象

class A
{
    void foo(){}
}

A obj=new A();
obj.foo(); //有多个线程想同时操作obj对象,A类的定义的代码不可见

synchronized (obj){
    //同步块
    obj.foo(); //同步的方法

}

java API设计已经考虑了同步类库

ArrayList 类此实现不是同步的,当在多线程来操作该对象会发生不同步.
解决方案1
synchronized (arrayList){
    //同步块
    arrayList.foo(); //同步的方法

}

或方案2
List list = Collections.synchronizedList(new ArrayList());
方案3
Vector 类 是同步的。线程安全的

小结:
java并发处理
1.java 并发基于线程来实现
2.创建线程两种方法
2.1 继承Thread 类   简单适合不用其他父类
2.2 实现Runnable接口 适合需要其他父类
3.线程的生命周期
4.主线程+子线程实现案例
5.控制线程的方法
join()
同步 synchronized
6.java 类库 支持并发的类
Vector
StringBuffer


java 网络编程


基于TCP socket通信的编程模型

需要api 类库有哪些?

java.net包

ServerSocket 类  用来做服务器等待客户端连接请求

ServerSocket(int port) 
Socket accept()   等待客户端连接请求的方法,该方法无连接请求会阻塞
            当连接成功建立,返回一个Socket对象
            


Socket 类
Socket(String host, int port) //host服务器ip/名称
 InputStream getInputStream() 
 OutputStream getOutputStream() 
 
案例1:
从客户端控制台输入口令字符串发送到服务器验证,返回验证结果到客户端屏幕.

案例2:
实现多个客户端连接服务器,每个客户端向服务器发送数据,服务器响应对应的客户端.
 

                            
                        
                    
                    
                    

你可能感兴趣的:(java 课堂总笔记)