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类型的柜子
衣柜
书柜
酒柜
鞋柜
柜子