Java学习笔记

最新推荐文章于 2021-02-27 02:35:21 发布

xuchen_si

最新推荐文章于 2021-02-27 02:35:21 发布

阅读量561

点赞数

文章标签： java

本文链接：https://blog.csdn.net/xuchen_si/article/details/20770917

版权

一、8种数据类型

1字节(byte)=8个位bit

数据类型	关键字	占用字节	取值范围	默认值
布尔型	Boolean	1	True,false	false
字节型	byte	1	-128~127	0
短整型	short	2	-2·15~（2·15）-1	0
整型	int	4	-2·31~（2·31）-1	0
长整型	long	8	-2·63~（2·63）-1	0
字符型	char	2	0~（2·16）-1	‘\u0000’
单精度浮点型	float	4	1.4013E-45~3.4028E+38	0.0F
双精度浮点型	double	8	4.9E-324~1.7977E+308	0.0D

自动类型转换: byte\short\int->float->long->double， byte\short\int不互相转换，三者计算时会转换成int类型

强制类型转换 long g=1000L int i=(int)g 布尔类型不能转换成其他任何数据类型

二、关键字

三、数组

int x[];

int[] x=new int[3]

int[] x=new int[]{3,4,5}

int[] x={1,2,3,4}

多维数组 int[] x=new int[3][4];

四、面向对象

构造方法： Duck d=new Duck(); 如果存在多参数的时候默认会覆盖无参的，如果需要则必须写出来（默认开发的话保留初始化构造方法）

方法重载：方法名相同，参数有多个，参数顺序不同函数不同

方法重写：

1.发生方法重写的两个方法返回值，方法名，参数列表必须完全一致（子类重写父类的方法）

2.子类抛出的异常不能超过父类相对应方法抛出的异常(子类异常不能大于父类异常)

3.子类的方法访问级别不能低于父类相应方法的访问级别（子类访问级别不能低于父类访问级别）

匿名对象：new Duck().func(); 特点只能使用一次，只使用一次对象，即可这样使用，直接在堆内存中开辟空间，会被GC回收，不易多次使用，以免产生垃圾

String类两种赋值:

String s1=new String("abc"); //会创建2个字符串对象，一个是堆内存new String("abc"),一个是创建字符串常量池对象

String s2="abc" //这里先去字符串常量池查找有没有“abc”,如果没有就在字符串常量池创建，并指向常量池字符串

String类编译期和运行期：

String a="a1"; 编译期就确定了值

String a1="a"+1; 编译期确定了值 //a==a1 true

String b="b1"; 编译期就确定了值

int bb=1; 编译期确定了值

String b1="b"+bb; 编译期无法确定值，bb是个变量，只有到运行期才能确定具体值 //b==b1 flase

String c="c1"; 编译期就确定了值

final int cc=1; 编译期确定了值

String c1="c"+cc; 编译期CC已被常量1替换，所以确定具体值 //c==c1 true

String d="d1"; 编译期就确定了值

final int dd=getDD(); 编译期无法确定

String d1="d"+dd; 编译期dd函数还没有被指向，必须到运行期dd才能被函数的返回值1替换成常量，所以确定具体值 //d==d1 true

Static关键字（静态数据不是属于对象，属于类）

static修饰的变量存放在内存方法区，在内存里面只创建一份数据

static方法里面不能调用this、super类对象关键字

static只能修饰内部类

五、对象数组

class ObjArray

{

public static void main(String[] args)

{

ManageMonkey mm=new ManageMonkey();

mm.add(new Monkey("张三",'m'));

mm.add(new Monkey("李四",'w'));

mm.add(new Monkey("王五",'m'));

mm.add(new Monkey("cc",'m'));

mm.list();

System.out.println("##############################");

/*Monkey m=mm.find("张三");

m.print();

System.out.println("##############################");

mm.edit("李四",'女');

mm.list();

System.out.println("##############################");*/

mm.del("cc");

mm.list();

}

//管理猴子类

class ManageMonkey

{

private Monkey[] mokenys=new Monkey[4];

private int count=0; //当前对象个数

public ManageMonkey(){}

//添加对象

public void add(Monkey m){

if(count<mokenys.length){

mokenys[count]=m;

count++;

}else{

System.out.println("对象数组已满");

}

//删除对象

public void del(String name){

for(int i=0;i<count;i++){

if(mokenys[i].getName().equals(name)){

for(int j=i;j<count-1;j++){

mokenys[j]=mokenys[j+1];

}

mokenys[count-1]=null;

count--;

}

//查找对象

public Monkey find(String name){

for(int i=0;i<count;i++){

if(mokenys[i].getName().equals(name)){

return mokenys[i];

}

return null;

}

//修改对象

public void edit(String name,char sex){

Monkey m=find(name);

m.setSex(sex);

}

//打印数组对象

public void list(){

for(int i=0;i<count;i++){

mokenys[i].print();

}

//猴子对象

class Monkey

{

private String name;

private char sex;

public Monkey(){}

public Monkey(String name,char sex){

this.name=name;

this.sex=sex;

}

public void setName(String name){

this.name=name;

}

public String getName(){

return name;

}

public void setSex(char sex){

this.sex=sex;

}

public char getSex(){

return sex;

}

public void print(){

System.out.println("name="+name+",sex="+sex);

}

六、foreach使用（只适合遍历，不适合android这样对内存要求比较高的开发，因为他会不断的产生内存对象）

可变参数用法（参数列表里面只能有一个可变参数，并且可变参数只能在最后一个）

method (int num,String... names){

for(String name:names){

System.out.print(name);

}

调用的

method("123","cvb","qw","fgh");

七、代码块

1、普通代码块：在方法中使用，作用域只在最近的{}内

2、构造代码块：在构造对象时调用，在类中的代码块，先于构造方法执行

3、静态代码块：在构造代码块前加上static,在类加载时只执行一次

八、单例设计模式（面试）[构造方法私有化，静态方法获取对象]

饿汉式

class Singleton

{

private static Singleton s=new Singleton();

private Singleton(){}

public static Singleton getInstans(){

return s;

}

public void print(){

xxxxx

}

懒汉式

class Singleton

{

private static Singleton s=null;

private Singleton(){}

public static Singleton getInstans(){

if(s==null){

s=new Singleton();

}

return s;

}

public void print(){

xxxxx

}

八、final关键字

1.final声明一个类，该类不能被继承

2.final声明一个方法，该方法不能被子类重写

3.final声明一个常量，如果数据类型是类类型，那么地址不能变

九、抽象类（abstract）

抽象类可以没有抽象方法，有抽象方法的类必须是抽象类

非抽象类继承抽象类的时候，必须实现抽象类里面的所有抽象方法

抽象类可以有方法和属性

抽象类不能被实例化

抽象类不能被final

十、接口

interface hit{

public void cry()

}

class god implements his{

}

1.接口可以继承多个

2.一个类可以实现多个接口

3.抽象类实现接口可以不实现接口里面的方法

4.接口中所有的方法全部是public

5.接口中所有的属性都是常量而且是静态的

十一、多态

向上转型：将子类实例转为父类实例格式：父类父类对象=子类实例 (new 谁就调用谁的方法)

向下转型：子类对象转变成父类格式:子类子类对象=（子类）父类实例

多态性:

1.方法的重载与重写就是方法的多态性表现

2.多个子类就是父类中的多种形态

3.父类引用可以指向子类对象，自动转换

4.子类对象向父类引用需要强制转换（注意：类型不对会报异常）

5.在实际开发中尽量使用父类引用（更利于扩展）

十二、内部类

12.1 成员内部类

Outer out=new Outer(); //产生外部类

Outer.Inner in=null; //声明内部类对象

in=out.new Inner();//创建内部类实例

12.2 方法内部类

//方法内部类只能在该类方法里面实例化（作用域决定）

func (){

class Inner{

funcInner(){}

}

Inner i=new Inner();

i.funcInner();

}

//方法内部类对象不能使用该内部类所在方法的非final局部变量

//局部变量的属性生命周期没有内部类的生命周期长

func (){

int x=10; //Q1 final int x=10;

class Inner{

funcInner(){

System.out.println("x="+x); //Q1 此时这里的x 必须定义为final

}

}

Inner i=new Inner();

i.funcInner();

}

12.3静态内部类

//静态内部类只能访问静态属性

外部实例化静态内部类 Outet.Inner oi=new Outet.Inner(); //一个静态内部类相当于外部类

12.4 匿名内部类

原则：

1.不能有构造方法，只能有一个实例

2.不能定义任何静态成员、静态方法

3.不能是public\protece\private\static

4.一定是在new的后面，用其隐含实现一个接口或实现一个类

5.匿名内部类为局部的，所以局部内部类的所有显示都对齐生效

12.4-1继承式匿名内部类

main:

Dog d=new Dog(){

public void say(){}

};

d.say();

12.4-2接口式匿名内部类

interface Child{

public void say();

}

main:

Child c=new Child(){

public void say();

};

c.say();

12.4-3参数式匿名内部类

interface Child{

public void say();

}

main:

func(new Child(){

public void say(){xxxxxx}

});

public static void func(Child c){

c.say();

}

十三、链表

class LinkList //链表类demo

{

public static void main(String[] args)

{

NodeMange nm=new NodeMange();

nm.addNode("节点1");

nm.addNode("节点2");

nm.addNode("节点3");

nm.addNode("节点4");

nm.addNode("节点5");

nm.printNode();

nm.delNode("节点3");

nm.printNode();

}

//链表节点管理

class NodeMange{

private Node root;//根节点

//添加节点

public void addNode(String name){

//判断根节点是否为空

if(root==null){

root=new Node(name);

}else{

root.add(name);

}

//删除节点

public void delNode(String name){

if(root!=null){

if(root.name.equals(name)){

root=root.next;

}else{

root.del(name);

}

//打印节点

public void printNode(){

if(root!=null){

System.out.print(root.name);

root.print();

System.out.println();

}

//定义节点内部类

class Node{

//节点名称

private String name;

//表示下一个节点对象

private Node next;//把自己的类型作为属性类型（单向链表）

public Node(String name){

this.name=name;

}

//添加节点

public void add(String name){

if(this.next==null){

this.next=new Node(name);

}else{

this.next.add(name);

}

//删除节点

public void del(String name){

if(this.next!=null){

if(this.next.name.equals(name)){

this.next=this.next.next;

}else{

this.next.del(name);

}

//输出节点

public void print(){

if(this.next!=null){

System.out.print("-->"+this.next.name);

this.next.print();

}

十四、数据类型包装类

1.基本数据类型包装类

Number:Integer、Short、Long、Double、 Float 、Byte都是Number的子类表示是一个数字

Object:Character、Boolean都是Object的直接子类

基本数据类型	包装类
Boolean	Boolean
byte	Byte
short	Short
int	Integer
long	Long
char	Character
float	Float
double	Double

2.装箱及拆箱操作（将基本数据类型转换为包装类即装箱，将一个包装类转换为基本数据类型即拆箱）

Integert x=10 (当直接赋值是，当值为1个字节内的数时，将使用同一个对象)【-128~127】

十五、异常处理

1.try{

//有可能发生异常的代码段

}catch(异常类型对象a){

//异常处理的操作

}catch(异常类型对象b){

//异常处理的操作

}

父类异常应该写在最下面，优先匹配子类异常

finally 即使return了 finally也会先执行了在执行return

2.throw与throws

public class ExceptionDemo2 {

public static void main(String[] args) {

try{

add();

}catch(Exception ex){

ex.printStackTrace();

}

public static int add()throws Exception{

Scanner input =new Scanner(System.in);

try{

System.out.println("请输入第一个数：");

int num1=input.nextInt();

System.out.println("请输入第二个数：");

int num2=input.nextInt();

return num1+num2;

}catch(Exception ex){

throw new Exception("加法运算异常");

}finally{

System.out.println("运算结束");

}

十六、StringBuffer类

对于字符串管理比String类更高效，StringBuffer[适合多线程]和StringBuilder[适合单线程]

十七、国际化（locale类）

可以在IE浏览器属性语言里面找到对应的语言编号

Locale local=new Locale("zh","CN");

Locale local2=Locale.US; //代码常量

Locale local3=Locale.getDefault(); //根据系统默认语言环境

定义语言包后缀 *.properties

info_zh_CN.properties

username=xxxxx

调用

ResourceBundle res=ResourceBundle.getBundle("com.vine.i18n.info",locale);

String username=res.getString("username");

处理动态文本

username=xxxxx {0}//占位符 xxx.[admin]谁登陆就显示谁

MessageFormat.format(username,'admin');

十八、常用工具类

Math数学类，Random随机数类，Array数组类，Date日期类，Calendar日历类，DataFormat和SimpleDateFormat日期格式化类

十九、对象比较器

自定义对象如果排序，必须实现Comparable接口compareTo方法

Class Persion implements Comparable<Person>

public int compareTo(Person o){

if(o==null){

throw new NullpotionException();

}

return 0;

if(this.age>o.age){

retuen 1;

}else if(this.age<o.age){

return -1

}

或者自定义比较器类

Class PersionComparable implements Comparable<Person>{}

Arrays.sort(Person,PersionComparable );

二十、对象的克隆

在Object对象中存在一个clone()方法，如果某个类的对象想要被克隆，则对象所在的类必须实现Cloneable接口，此接口没有定义任何方法，是一个标记接口

二十一、IO

1.File类目录遍历和文件遍历

2.字节输出流 outputStream os=new FileOutputStream类 //文件写入

3.字节输入流 InputStream in = new FileInputStream("g:\\1.txt"); //文件读取

4.字符输出流

public static void write1() {

File f = new File("g:\\1.txt");

try {

//构造一个字符输出流对象

Writer w = new FileWriter(f,true);

String info="好好学习,天天向上";

w.write(info);

w.close();

} catch (IOException e) {

e.printStackTrace();

}

5字符输入流（这样防止乱码，文本文件适合）

public static void reader1() {

File f = new File("g:\\1.txt");

try {

Reader in = new FileReader(f);

char[] cs = new char[20];

int len = -1;

StringBuffer sb = new StringBuffer();

while ((len = in.read(cs)) != -1) {

sb.append(new String(cs, 0, len));

}

in.close();

System.out.println(sb);

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

6.对象序列化（对象必须实现seralizable接口才能被序列化）

7.字节数组流

二十二、集合框架

二十三、线程和进程

线程是进程的进一步划分，一个程序可以看做是一个进程，执行过程可以可以划分多个线程，线程之间可以互相切换

多线程的实现方式

1.继承Thread类 ------myThread.start()启动线程

2.实现Runnable接口run方法 //更推荐使用runnable方法启动线程，自定义类的话继承的话受限于Threadf单继承

MyRunnabe mr=new MyRunnabe();

Thread t=new Thread(mr);

线程同步机制

object obj=new Object();

方式一：synchronized（obj）{

同步代码块

}

方式二：public function synchronized run(){

同步代码块

}

二十四、反射

Java的类反射所需要的类并不多，它们分别是：Field、Constructor、Method、Class、Object

二十五、內省机制

内省(IntroSpector)是Java 语言对 Bean 类属性、事件的一种缺省处理方法。例如类 A 中有属性 name, 那我们可以通过 getName,setName 来得到其值或者设置新的值。通过 getName/setName 来访问 name 属性，这就是默认的规则。 Java 中提供了一套 API 用来访问某个属性的 getter/setter 方法，通过这些 API 可以使你不需要了解这个规则（但你最好还是要搞清楚），这些 API 存放于包 java.beans 中,一般的做法是通过类 Introspector 的 getBeanInfo方法来获取某个对象的 BeanInfo 信息,然后通过 BeanInfo 来获取属性的描述器(PropertyDescriptor),通过这个属性描述器就可以获取某个属性对应的 getter/setter 方法,然后我们就可以通过反射机制来调用这些方法。

JavaBean 必须含有get\set方法

相关API：IntroSpector 、BeanInfo、Properties（负责读取*.properties文件）

二十六、泛型

1、泛型

2、通配符

public void method(Person<?> p){

P.getAge(); 只能调用，不能修改

}

上限： public class Person<T extends Number>{} //必须是Number的子类

下限:public function method(Person<? super String> p){} //必须是string的父类

3、泛型接口

public interface Test<T>{