System.out.println(); 输出

int 整数类型 不能以数字开头 区分大小写
int a=0  
int的范围2的31次方到-2的31次方  21亿左右
2个int型运算后仍为int
除法没有余数14/5=2  
%模运算 14%5=4 求余数.


double 双精度浮点型  比较大非无限
double c=123.456  double e=-123.456
浮点型除法保留小数.
double类型则不能使用双等号来比较大小，如果使用的话得到的结果将永远是不相等



String s="abcd" 字符串类型


变量的赋值= 

布尔类型变量 boolean
boolean只能为 true 或者 false

ctrl+/ 群体注释

类型的提升 int和double做运算 强制提升int为double;


表达式和操作符
表达式 Expression
操作符 Operator

关系表达式的值为boolean类型的值;
==双等号 判断两个变量是否相等


类变量：独立于方法之外的变量，用 static 修饰。
实例变量：独立于方法之外的变量，不过没有 static 修饰。
局部变量：类的方法中的变量。

逻辑非!   逻辑与&&   逻辑或||

=赋值 a=b 


int a=1;//初始化
a=123;//赋值
final a =0;
当你在类中定义变量时，在其前面加上final关键字，那便是说，这个变量一旦被初始化便不可改变，
这里不可改变的意思对基本类型来说是其值不可变，而对于对象变量来说其引用不可再变，
但引用变量所指向的对象中的内容还是可以改变的。

a +=b //a=a+b 
a -=b //a=a-b
a *=b//a=a*b
a/=b //a=a/b
a %=b//a=a%b

a++自增操作符;
a++为后置自增　int b=10; a=b++;  //a输出为10,b为11
++a为前置自增  int b=10; a=++b;  //a输出为11,b为11

优先级与类型转换
double a=12.77;
int b=(int)a;//b值为12直接截断小数部分.

单行调试技术
1.加断点 右键 debug as

条件语句 if语句
if else 
if{} else if{}

for循环
for(e1;e2;e3)  e2>>s1>>e3  e2为false跳出循环
{s1
}

for循环的嵌套 for循环嵌套if语句


break语句和continue语句

break中止当前循环, continue跳出当前轮循环.



数组对象
int[] arr=new int[30]// 创建一个数组对象,容纳30个int
arr[0]第一个元素 arr[29]第30个元素;
arr[i],i叫索引或者下标. 下标从0开始;

int[] arr={1,2,3,4,5};
for(int i=0;i<arr.length;i++)


数组的遍历
通过for循环实现遍历.
int[] a=new int[4];  变量a指向了一个对象

int[] b=a;   //b和a指向了同一个对象  a和b都是该对象的引用,a可以操作目标对象,用b也可以操作目标对象

空对象 null
null:表示一个引用不指向任何对象
int[] a={11,11,11,11};
int[] b=a;

a=null;

空指针错误, 
int[] a={11,11,11,11};
a=null;
a[0]=12;//报错  

失去引用的对象
int[] a={8,8,8};   //失去引用的对象   
a=new int[4];
a[0]=a[1]=a[2]=a[3]=17;

失去引用的对象会被Java环境自动删除.

类的概念
类,class.一个class可以若干基本类型的组合.
类Student
    public String id; //学号
    
    public String name; //姓名
    
    public boolean sex;//性别
    
    public String cellphone;//手机号

Student s1=new Student()

s1.name="XX"

1.类型名Student,  2.属性 学号,姓名,性别,手机号.

类型是描述一类事物的共性,对象是一个具体的实例;

类的嵌套,类的属性可以是另一个类.


boolean类型的默认值是false

double类型的默认是null  



类的方法Method
public void 方法名() 
{
} 
//修饰符  返回值类型  名称(参数列表)   {方法体}
调用方法.


方法的参数
参数列表 0-N个参数,以逗号分隔,类型,变量名
public void sohw(int a,double b,String c)

方法的返回值
return语句来返回一个值,
return语句执行后方法不再往下执行.

public int show()
打印输出只是方便调试结果,

可以在void的返回值时下用return结束函数.

return 的返回值可以是各种类型.

方法名的重载overload
方法名可以相同只要参数不同就行.


第八章当前对象(this)
this调用当前对象中的

在访问自己的方法时this.可以省略.
当名字发生重名时不能省略.

public class Triangle
{
    public int a;
    public int b;
    public String value()
    {
        return a+"/"+b;
    }
    public Triangle mul(Triangle other)
    {
        Triangle c=new Triangle();
        c.a=this.a*other.a;
        c.b=this.b*other.b;
        return c;
                
    }
}
    时
        Triangle a=new Triangle();
        a.a=1;
        a.b=2;
        Triangle b=new Triangle();
        b.a=2;
        b.b=3;
        
        Triangle c=a.mul(b);
        System.out.println(c.value());


第九章 访问修饰符
public(公开的)该成员可以被外部访问 visible可见

private(私有的)不可访问,not visible不可见 内部访问不受private限制

不写访问修饰符一般为private


getter 和setter   读/写  get读  set写    
getNumber  setNumber

private int number

public int getNumber()
{
  return this.number;
}
public void setNumber(int number)
{
 this.number=number;
}
封装

第十章构造方法
用于构造对象的方法(当创建对象时调用的方法)
规则1.方法名与类包相同 2.无返回值
        public String id;
    public String name;
    public boolean sex;
        public Student()
{
}
    public Student(String id,String name,boolean sex)
{
    this.id=id;
    this.name=name;
    this.sex=sex;}

构造方法可以有多个,一般要加一个默认构造方法即无参数构造方法.
构造方法一般是public修饰    ,特殊情况用private修饰.

当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。
通常会使用构造方法给一个类的实例变量赋初值，或者执行其它必要的步骤来创建一个完整的对象。
不管你与否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个默认构造方法，它把所有成员初始化为0。
一旦你定义了自己的构造方法，默认构造方法就会失效。

对象的销毁
只管创建对象,不用销毁对象,对象由系统自动销毁.
Student s=new Student();

GC垃圾回收机制,回收不被使用的对象.

第11章继承
public class B extends A 
{
}
继承写在子类的前面.
表示B继承于A A:父类(supercalss) B:子类(subclass)

类B继承于A时,自动继承A中的public属性/方法.

子类拥有父类非private的属性，方法。

重写
如果父类的方法不满足要求,则可以在子类重写.
在子类右键Source 选Override

完全重写和父类基础上补充.

super.xxx();


构造方法的继承
public class Triangle //父类
{
    public double a;    
    public double b;
    public double c;
    
    public Triangle()
    {
    }
    public Triangle(double a,double b,double c) //构造函数
    {
        this.a=a;
        this.b=b;
        this.c=c;
    }

public class RightTriangle extends Triangle//子类
{
    
    public RightTriangle(double a,double b,double c) //调用父类的构造函数
    {
        super(a,b,c);
    }
先调用父类的构造方法,再调用子类的.

多个构造函数 用super(加参数),用的什么参数就调用那个构造方法.

单根继承
Java的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，
多重继承就是，例如A类继承B类，B类继承C类，所以按照关系就是C类是B类的父类，
B类是A类的父类，这是java继承区别于C++继承的一个特性。

右键 Quick Type Hierarchy    

Object类
Java中Object是所有类的父类  如果一个类没有指定父类,则它默认父类是Object

Object类的toString对象
    public String toString()
    {
        String s="学号"+id+"姓名"+name;
        if(sex)
        {
            s=s+"男";
        }
        else
        {
            s=s+"女";
        }
        return s;
    }



多态
重载Overload  重写Override  泛型.

1.子类和父类的类型转换(隐式转换)
ApplePie p1=new ApplePile();
Pie p2=p1;    //类型转换ApplePie->Pie

2.父类转换成子类需要谨慎
ApplePie p3=(ApplePie)p2;//显式转换
p2实际指向ApplePie 所以可以转换.

看实际指向对象的具体类型,再调用实际指向对象的具体类型.

所有类型都是Object的直接或间接子类,所以
Object x=new MyFileVideo(); 没有问题


第12章 包
建包 new package
包的命名方式xx.xx.xxx  也是包的保存路径xx/xx/xxx
package xx.xx.xxx 表示本类所在的包的路径

import xx.xx.xxx.*; 一次性导入该包下所有的类

包的显式:Flat 扁平化显示, Hierarchical 层级显示 推荐

eclipse 的快捷操作\
文件可以拷贝.
Refresh同步
包名重复

改名修改包名,类,方法,属性
选中,右键Refactor rename. 使用到它的地方自动改名.
保存ctrl+s,注释 Ctrl+/,  Ctrl+鼠标左键 查看定义,
打开提示 alt+/, 


  第13章静态方法.
该方法没有访问this对象,即没访问this属性,也没访问this方法.
称为静态方法(全局方法)
没有上下文单纯的方法.

静态方法用static修饰
public static boolean isPrime(int n)
{
}
静态方法可以不创建对象
Xxx a=new Xxx()可以不写.
2
Math类:有很多计算静态方法
abs(a):求绝对值;
pow(a,b):求a的b次幂
sqrt(a):求a的平方根
round(a):四舍五入
sin/cos/tan:正弦/余弦/正切

程序的入口
只有main方法可以做为程序得到入口

public static void main(String[] args)

由于是static全局方法,可以放在任意一个类下面.
main方法的形式是约定好的.


单元测试
写好一个类后 添加一个main方法,对一个类进行测试.

第14章 常见工具类

String 字符串
String s="人好nihao";    //中文字符和英文字符都占一个字符
int n=s.length();    //n=7;

空字符串
String s="";   //空字符串和null是两回事!      空字符串是一个正常的字符串对象,null不指向任何对象.

子串
String s="人好nihao";
String sub=s.substring(0,4); //0,1,2,3,不包含4   

substring(beginIndex,endIndex)不含endIndex;


判断内容是否相同
字符串必须使用 equals
String s1="nihao";
String s2="nihao";
if(s1.equals(s2))
{
System.out.println("相同");
}

比较大小:按字典序比较 s1.compareTo(s2)<0    忽略大小写的比较用compareToIgnoreCase
String s1="abcd";
String s2="acef";
if(s1.compareTo(s2)<0)
System.out.println(s1+"位于前面");
else
System.out.println(s2+"位于前面");


格式化
String s=String.format("姓名:%s,年龄:%d,身高:%.2f","名字",35,1.75);
String.format()是一个静态方法
格式化时 %s对应字符串  %d整数  %.2f表示显示2位小数


查找 indexOf
如果有这个子串,则返回位置索引;否则返回-1;
String c="China is a great country";
int pos=s.indexOf("great");
if(pos<0)
{
System.out.println("没找到");
}
//查询s1中我出现的次数
        String s1="对角线我,我阿达,我,阿萨德";
        int count=0;
        int start=0;
        while(start<s1.length())
        {
            int pos=s1.indexOf("我",start);    //indexOf 查找的字符类型,加开始查询的地址参数.
            if(pos<0)
                break;
            count+=1;
            start=pos+1;
        }
        System.out.println(count);

前缀后缀
startsWith()  判断前缀
endsWith()  判断后缀

String d="country.mp4";
if(d.endsWith(mp4))
{
System.out.println("是mp4格式");
}

基本类型与包装类型
long<=>Long
int<=>Integer
short<=>Short
byte<=>Byte
double<=>Double
float<=>Float
boolean<=>Boolean

int a=10;
Integer b = new Interger(10);

    Integer a=new Integer(10);
    int b=a.intValue();
    System.out.println(b);
    
    Integer k=123;
    int m=k;
    System.out.println(m);


数值<=>String
int->String
String a="123"
int b=Integer.valueOf(a);  //a

String->int
String s=String.valueOf(339);

包装类的作用
提供转换方法,把所有类型统一到类的范畴,都是Object的子类.

控制台Console
控制台在正式开发中不会用到.
用于语法练习,模拟用户交互.  //语法,逻辑

随机数的使用
Random类JDK自带的基本类
java.util.Random

import java.util.Random;
Random rand=new Random();
for(int i=0;i<3;i++)
{
int s=rand.nextInt(1000);
System.out.println("生成随机数"+s);
}

不允许重复的情况

char类型  字符类型
char c1 ='A';

字符的编码
char c1 ='A';
int n =c;
System.out.println("生成编码"+n);

A为65,B 66 ,a 97,b 98, 0为48.  空格 为32.
0-128之间称为ASCII码(仅有英文数字,符号)

字符串和字符
String=>char
String str="afanihao"
char ch=str.charAt(8);  //下标从0开始计算
char[] chs=str.toCharArray();

char=>String
char[] chs={"啊","你","好"};
String str=new String(chs,0,2);
str+='的';    

第15章链表
容器:存储对象的东西
容器是设计术语,非语法概念.
比如数组就是一个容器.

数组容器的确定,容量固定,无法扩展
插入和删除困难,插入对象的代价太多,需挪动现有对象.


15.2  链表(Linked List)  链表是一种组织数据的方式,可以把若干对象串联起来.
public class Monkey
public Monkey next;
Monkey m1=new Monkey(101,"XX")
Monkey m2=new Monkey(102,"XX")
Monkey m3=new Monkey(103,"XX")
Monkey m4=new Monkey(104,"XX")
m1.next=m2;
m2.next=m3;
m3.next=m4;
m4.next=null;

以链状形式串起来的.最前面的为链表头.
节点Node;

链表的遍历
Monkey node=m1;       //知道头节点的位置.
while(node!=null)     //当节点不指向空时
{
System.out.println("链表"+node);   //输出
node=node.next;            //指向下一个节点
}

15.3
链表插入与删除节点.
1.附加到末尾
Monkey m1=new Monkey(101,"XX")
Monkey m2=new Monkey(102,"XX")
Monkey m3=new Monkey(103,"XX")
Monkey m4=new Monkey(104,"XX")
m1.next=m2;
m2.next=m3;
m3.next=m4;
m4.next=null;

//找到链表的最后一个节点
        Monkey tail=m1;
        while(tail!=null)
        {
            if(tail.next==null)
            {
                break;
            }
            else
            {
                tail=tail.next;
            }
        }
        tail.next=m5;

2.插入第一位置之后

Monkey hard=m1;
m5.next=m1.next;  //m5的尾部指向m1的尾部;
m1.next=m5;       //m1的尾部指向m5;
 

3.插入指定位置
插到102之后
        Monkey head = m1;
        while (head != null)
        {
            if (head.id == 102)
            {
                m5.next = head.next;
                head.next = m5;
                break;
            }
            else
            {
                head = head.next;
            }
        }

删除节点.
m1.next=m3; //删除m2;

15.4
有头链表;
用一个固定的假节点充当头节点.此节点不算做链表长度,简化算法.

Monkey m1=new Monkey(101,"XX")
Monkey m2=new Monkey(102,"XX")
Monkey m3=new Monkey(103,"XX")
Monkey m4=new Monkey(104,"XX")
m1.next=m2;
m2.next=m3;
m3.next=m4;
m4.next=null;
Monkey head=new Monkey(0,"XX");
head.next=m1;

遍历
Monkey m=head.next;
while(m!=null)
{
System.out.println("链表"+m);
m=m.next
}

插入节点
插入在头部
Monkey m5=new Monkey(105,"XX");
    m5.next=head.next;    //插入节点时 先定义需要插入节点的尾部,
    head.next=m5;         //插入节点时 再定义需要插入节点的头部.
//插入在尾部
Monkey node1 = head;
        while(node1!=null)   //找到最后位置.
        {
            if(node1.next==null)  
            {
                break;
            }
            else
            {
                node1=node1.next;
            }
        }
        m5.next=null;
        node1.next=m5;



删除节点
        Student a=new Student("101","A");
        Student b=new Student("102","B");
        Student c=new Student("103","C");
        Student d=new Student("104","D");
        Student head=new Student("0","head");
        
        head.next=a;
        a.next=b;
        b.next=c;
        c.next=d;
        d.next=null;
        
//删除节点
1.        Student n=head.next; 101 
        Student p=head;
        while(n!=null)
        {
            if(n.id=="102")
            {
                p.next=n.next;
                break;
            }
            p=p.next;
            n=n.next;
        }

//删除节点
2.        Student node=head;
        while(node.next!=null)
        {
            if(node.next.id=="102")             //判断是否是要删除的节点
            {
                node.next=node.next.next;   //实现删除节点
                break;
            }
            node=node.next;                     //往下个节点走.

        }

//遍历
        Student i=head.next;
        while(i!=null)
        {
            System.out.println("链表为"+i);
            i=i.next;
        }

链表和容器
XXXList
黑盒,容器是不透明的,不需要关心它是如何内部存储对象的.

public class Monkey    //定义monkey类

{
    public int id;
    public String name;
    public Monkey next;
    
    public Monkey()
    {
        
    }
    public Monkey(int id,String name)
    {
        this.id=id;
        this.name=name;
        
    }
    @Override
    public String toString()
    {
        
        return String.format("id:%d, 名字:%s",id,name);
    }


    

}

public class MonkeyList      //链表存储实现容器
{
    
    Monkey head=new Monkey(0,"石猴");
    
    //添加对象
    public void add(Monkey m)
    {
        m.next=head.next;
        head.next=m;
        
    }
    
    //编号查找
    public Monkey get(int id)
    {
        Monkey node = head.next;
        while (node != null)
        {
            if(node.id==id)
            {
                return node;
            }
            node = node.next;
        }
        return null;
    }

}

    MonkeyList lst=new MonkeyList();    //主函数
        
    Monkey m1 = new Monkey(100, "圆圆");
    Monkey m2 = new Monkey(101, "芳芳");
    Monkey m3 = new Monkey(102, "谢谢");
    Monkey m4 = new Monkey(103, "哦哦");
    Monkey m5 = new Monkey(104, "最后添加的");


    lst.add(m1);                   //实现添加
    lst.add(m2);
    lst.add(m3);
    lst.add(m4);

    Monkey a=lst.get(102);          //查找的实现
    if(a!=null)
    {
        System.out.println("找到了"+a);
    }



数组链表ArrayList
import java.util.ArrayList;

                Student a=new Student("101","A");
        Student b=new Student("102","B");
        Student c=new Student("103","C");
        Student d=new Student("104","D");
        
        ArrayList x=new ArrayList();
        
        x.add(a);
        x.add(b);
        x.add(c);
        x.add(d);
        
        for(int i=0;i<x.size();i++)
        {
            Student s=(Student)x.get(i);
            System.out.println("遍历得到"+s);
        }


删除 x.remove(1)    //索引