lnwdh笔记

最新推荐文章于 2024-04-13 10:21:22 发布

lnwdhboss

最新推荐文章于 2024-04-13 10:21:22 发布

阅读量420

点赞数

本文链接：https://blog.csdn.net/lnwdhboss/article/details/87922948

版权

本文档详细介绍了Java编程中常见的错误处理，包括访问权限错误及解决方案。接着探讨了Java集合框架，如MyBufferedReader和LineNumberReader。讲解了不同类型的流对象，如ByteArrayInputStream和CharArrayWriter，并提及设备是内存的流对象。此外，文章还涵盖了数据类型、进制转换、位运算、字符串操作、数组和对象的存储以及流的使用，包括BufferedReader、PrintStream和SequenceInputStream等。最后，提到了对象序列化和反序列化以及RandomAccessFile的相关知识。

摘要由CSDN通过智能技术生成

德昊德浩
DOS 磁盘操作系统
windows 图形化界面GUI
命令行方式 CLI

JVM java虚拟机-在操作系统上解析emmm

/*
Asdsad
Asdasd
*/
多行注释

/**
文档注释
asdsa
*/
Javadoc.exe 生成说明书-放在网页文件中
Set path =asdasda;%path%(增加path，保留原来）
Set classpath= asdawsad; //分号-----在指定目录下找完，在当前目录再找一遍

							DAY 2

Demo1_Test
Demo2_Eate
注释！

Byte-8位、1字节-8位

进制转换
八进制—二进制的三位是八进制的一位
十六．。。。。。四位 0xAE----10 14–10101110
负数的二进制–正数取反加1
0000 0110
取反1111 1001
+0000 0001
1111 1010------ -6
负数的二进制的最高位是1
Byte short int long
1 2 4 8
BYTE的范围
-2(7)-----2(7)-1
Float 4
Double 8默认
Char 2

强制类型转换
Byte b=3;
B=(byte)(b+4);
0000-0000 0000-0000 0000-0000 0000-0111
前三位扔了
0000-0111
ASC表
A-65
A-97

Byte b1=3; 3整数，4个字节，而BYTE一个字节
Byte b2=7;
Byte b;
B=b1+b2;
WRONG!
因为后面是两个不确定的变量，如果超了
-128^127 就gg
3+“2” 32 字符串+是连接

						DAY3

^ 异或相同为0不同为1
&& 短路，左面假右面就不运算，效率高
和与运算结果一样。
& 无论左面是啥，右面都参与运算
|| 短路左面为真，右面不运算

位运算
6&3-------=2
110
& 011
010

异或同一个数据两次，结果还是一样
加密
移位
3<<2=12 3<<3=24 (11000)
32（2）=12 32（3）=24
0000000000000000000000000000-0011
0000000000000000000000000000-1100
左移就是乘以2的次幂运算
6>>1=3
0110-------0011
(最高位是啥就那啥补，负数就拿1补)
右移就是除以2的次幂

无符号右移：数据进行右移时，高位出现的空位，
无论原高位是什么，空位都用0补

class OperateTest//输出2乘8的最有效率的方法–位运算
{
public static void main(String []args)
{
System.out.println(2<<3);
}
}

class Change//第三方变量chang
{
public static void main(String []args)
{
int a =3,b=4;
int c;
c=a;
a=b;
b=c;

	System.out.println("a="+a+",b="+b);
}

}

class Chang2//不用第三方变量
a=a+b;
b=a-b;
a=a-b;
//这种方式不用，数值过大超出int范围，强制转化

class Chang3//位运算方法
{
public static void main(String []args)
{
int a =3,b=5;
a=a^b; //a=3^5
b=a^b; //b=(3⁵⁾5;b=3
a=a^b; //a=(3⁵⁾3;a=5
System.out.println(“a=”+a+",b="+b);
}
}

三元运算符

class OperateDemo5//
{
public static void main(String []args)
{
intx=3,y;
y=(x>1)?100:200;
System.out.println(y);
}
}
三元运算符就是if else 语句的简写格式
当if else 运算后有个具体的结果时可以用简化
Int a ,b;
Int max = (a>b)?a:b;//获取两个整数中最大的

Int a,b,c;//获取三个数中最大的
Int temp=O>p?o:p;
Int max2=temp>q?temp:q;

如果if语句中只有一条语句可以不写{}
但只能控制哦这一条语句
class OperateDemo8//
{
public static void main(String []args)
{
int x=3;
switch(x)
{
case 4:
System.out.println(“a”);
break;
case 1:
System.out.println(“b”);
break;
case 3:
System.out.println(“c”);
break;
default:
System.out.println(“d”);
break;

}
}

}

Switch 只有四种类型能用
Byte short int char
如果遇到没有break的条，直接执行知道遇到break或者{}终止

遇到一样的，避免复杂

For里的变量在循环结束就释放------y
So
如果需要通过变量来对循环进行控制
改变量只作为循环增量，用while
（下面还能再用这个变量）
内存的问题emmmmm

//乘法表
public static void printCFB(int num)
{
for(int x=1;x<=num;x++)
{
for(int y=1;y<=x;y++)
System.out.print(y+""+x+"="+yx);
}
System.out.println();

}
//重载个数问题一般可以复用
public static void printCFB()
{
printCFB(9);
}

内存的划分

寄存器
2.本地方法区
3.方法区
4.栈内存
存储的都是局部变量
5.堆内存
存储的是数组和对象（其实数组就是对象）
凡是new建立的就是在堆中
特点
1.每一个实体都有首地址值
2.堆内存中的每一个变量都有默认的初始化值
根据类型的不同而不同。Int 0 小数0.0或者0.0f
Char’\u0000’ booleanfalse
3.垃圾回收机制，自动的，不定时的

\n :回车
\t: 制表符(tab)
\b:退格
\r:按下回车键
windows中回车符由两个符号组成\r\n
linux中回车符是\n

Break 用于swtich 和循环
Continue 用于循环

错误！！！！！！
直接继续循环，输出语句无法执行
用法！！！！！！！！！！！！！

Continue 结束本次循环，继续下次循环
Continue 和if配合emmm、

函数名第一个单词首字母小写，以后都大写首字母

Public static void myPrint()
{
System.out.println(“hello”);
}
Public static void main(String [] args)
{
myPrint();
}
不用return
函数的结果应该给调用者处理
返回值类型和参数类型无关
栈先进后出
重载----同一个类，允许存在一个以上的同名函数
只要他们的参数个数或者参数类型不同

/*函数的重载
1.同一个类
2.同名
3.参数个数不同or参数类型不同
*/

//加法运算两个整数
public static int add(int a ,int b)
{
return a+b;
}
//两个小数
public static double add(double a ,double b)
{
return a+b;
}
//三个整数
public static int add(int a ,int b，int c)
{
return a+b+c;
}

数组的遍历
/*
数组有个语句可以看长度arr.length

class ArrayDemo3
{
public static void main(String [] args)
{
int[] arr=new int[]{89,35,270,17};
//int [] arr={89,35,270,17};
For(int x =0; x<arr.length ; x++)
{
System.out.println(“arr[“+x+”]=”+arr[x]+”;”);
}
}
}

获取最值，数组

选择排序
class ArrayDemo4
{
public static void main(String []args)
{
int [] arr={34,19,11,109,3,56};
for(int x=0;x<arr.length;x++)
{
System.out.println(arr[x])
}
}
public static void xuanZe(int[]arr)
{
for(int x=0;x<arr.length-1;x++)
{
for(int y=x+1;y<arr.length;y++)
{
if(arr[x]>arr[y])
{
int temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
}
}
}
}

冒泡排序
相邻的比较，大的往上冒

//冒泡排序

for(int x=0;x<arr.length-1;x++)
{
for(int y=0;y<arr.length-1-x;y++)
{
if(arr[y]>arr[y+1])
{
int temp=arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;
}
}
}
//或者
for(int x=arr.length-1;x>0;x–)
{
for(int y=0;y<x;y++)
{
if(arr[y]>arr[y+1])
{
Swap(arr,y,y+1);//看下面的函数
}
}
}
Public static void swap(int [] arr,int a,int b)
{
Int temp =arr[a];
Arr[a]=arr[b];
Arr[b]=temp;
}

二分查找————————有序的数据//
class ArrayDemo5
{
public static void main(String []args)
{

	System.out.println("index="+index);               
}
public static int halfSearch(int key,int[] arr)
{
	Int max,min,mid;

Min=0;
Max=arr.length-1;
While (min<=max)
{
Mid=(max+min)/2;
If(key>arr[mid])
Min=mid+1;
Else If(key<arr[mid])
Max=mid-1;
Else
Return mid;

}
Return -1;/给定一个有序的数组，王数组中存个元素，保证还是有序的
Return min;/
}

Int index1=Arrays.binarySearch(arr,5);
//如果存在返回具体位置不存在的话，返回的是-插入点-1

获取一个整数的16进制表现形式
0000-0000 0000-0000 0000-0000 0011-1100–>60
& 0000-0000 0000-0000 0000-0000 0000-1111–>15
0000-0000 0000-0000 0000-0000 0000-1100–>12
取末位值，4位二进制是一个16进制位
然后60>>>4再&15----->3
–>3c

查表法------数组—映射关系，两组对照
有对应关系，一组有序
//定义一个容器临时放数据转换16进制
public static void toHex(int num)
{
if(num==0)
{
System.out.println(“0”);
return;
}
char[]chs={“0”,“1”,“2”,“3”,“4”,“5”,“6”,“7”,“8”,“9”,“A”,“B”,“C”,“D”,“E”,“F”};//定义一个对应关系表
char []arr= new char[8];
int pos =arr.length;
while(num!=0)
{
int temp=num&15;
arr[–pos]=chs[temp]
num =num>>>4;

	}
	for(int x=pos;x<arr.length;x++)
	{
		
	}
	System.out.println()

//定义一个容器临时放数据转换进制

class ArrayTest3
{
public static void main(String[]args)
{
toHex(26);
toBinary(26);
toOctal(26);
}
//十进制--------》十六进制
public static void toHex(int num)
{
trans(num,15,4);
}
//十进制--------》2进制
public static void toBinary(int num)
{
trans(num,1,1);
}
//十进制--------》八进制
public static void toOctal(int num)
{
trans(num,7,3);
}
public static void trans(int num,int base,int offset)
{
if(num==0)
{
System.out.println(“0”);
return;
}
char[]chs={“0”,“1”,“2”,“3”,“4”,“5”,“6”,“7”,“8”,“9”,“A”,“B”,“C”,“D”,“E”,“F”};//定义一个对应关系表
char []arr= new char[32];
int pos =arr.length;
while(num!=0)
{
int temp=num&base;
arr[–pos]=chs[temp]
num =num>>>offset;

	}
	for(int x=pos;x<arr.length;x++)
	{
		System.out.print(arr[x]);
	}

}

/*
二维数组的格式
Int [] arr=new int[3];一维数组
Int[][] arr=new int[3][2]; 2wei
System.out.println(arr[0][0]);
*/

int [][]arr=new int [3][];
分别对二维数组每一个小数组初始化
arr[0]=new int[2];
arr[1]=new int[1];
arr[2]=new int[3];
System.out.println(arr[1].length);打印二维数组中角标为1的数组的长度
Int[][] arr= { {3,1,7},{5,4,4,5},{3,1}};
For(int x=0;x<arr.length;x++)
{
For(int y=0;y<arr[x].length;y++)
{
System.out.println(arr[x][y]+”,”);
}
}
面向过程------强调动作（函数）
面向对象。
强调的是对象。（实体）。
三个特征：封装继承多态
Class：：描述事物的属性行为
对象是该类事物存在的个体（实例）
通过new创建
//在计算机中创建一个car的实例。通过new关键字
Car c =new Car (); /c是一个类类型的引用变量
指向了该类的对象/
c.run();//使用对象中的内容对象.成员
c.num =4;
c.color=”red”;
定义类就是定义类中的成员
成员：成员变量—》属性，成员函数----》行为
class Car
{
int num;
String color;
void run()
{
System.out.println(num+”…”+color);
}
}
new------在堆内存默认初始化值
栈。方法存地址指向堆

对象----封装数据
成员变量和局部变量的区别
1成员变量定义在类中，整个类都可以访问
局部变量定义在函数，语句，局部代码块中，只在所属的区域有效
2
成员变量存在于堆内存的对象中
局部变量存在于栈内存的方法中
3，
成员变量随着对象的创建而存在，随着对象的消失而消失
局部所属区域
4成员变量you默认初始化值
局部没有默认初始化值

public static void show(Car c)//类类型变量指向对象
{
c.num=4;
c.color=”black”
System.out…
}
show(c1);

匿名对象 :new car(); 定义对象的简写格式然而好像没啥用
正常:Car c=new Car();
c.run();

 new Car() .run();

1当对象对方法仅进行一次调用的时候可以简化成匿名对象
注意只是对方法
2匿名对象可以作为实际参数进行传递
class Demo
{
public static void main(String []args)
{
int x=3;
show(x);
System.out.println(x);

}
public static void show (int x)
{
x=4;
}
}
结果为3

封装：隐藏对象的实现细节和属性仅对外提供公共访问方式
安全，可控性—提供方法不直接访问成员

private私有只在本类中有效，用于修饰成员
注意：私有仅仅是封装的一种体现
class Person
{
private int age;//成员变量弄成私有的
public void setAge(int a)//一个成员变量对应俩方法规范
{
age =a;
}
public int getAge()
{
return age;
}
void speak()
{
System.out.println(“age=”+age);
}
}
封装原则
将不需要对外提供内容隐藏
把属性都隐藏，提供公共方法对其访问

构造函数：函数名与类名相同
不用定义返回值类型
没有具体的返回值
作用：
给对象进行初始化，创建对象就要用构造函数初始化
注意：

一个类没有定义过构造函数，会有默认的空参数构造函数在这个类中
2.如果累中定义了构造函数，那默认的构造函数就没有了

class Person
{
private String name;
private int age;
//定义一个构造函数
Person ()
{
System.out.println(“person run”)
}

public  void speak()
{
	Stystem.out.println(name+":"+age)
}

}

class ConsDemo
{
public static void main(String []args)
{
Person p = new Person();
}
}

结果是 person run

什么时候定义构造函数？
在描述对象时该对象就已经具备了一些内容，这些内容
都定义在构造函数里
class Person
{
private String name;
private int age;
}

Person()
{
name =”baby”
age =1;
}

Person (String n)
{
name =n;
}
Person(String n ,int a)
{
name =n;
age =a;

}

public void speak()
{
System.out.println(name+”:”+age);

}
public void setName(String n)// 封装
{
name=n;
}
class Demo3
{
Person p=new Person();
p.speak();
Person p1=new Person(“WANG”);//难听老子要改名字
p1.setName(”王蕊”);
p1.speak();
Person p2=new Person(“WANGG”,13);
p2.speak();}

this关键字:党成员变量和局部变量重名，用
this来区分--------this：代表对象。
this就是所在函数所属的对象的引用
（那个对象调用了this所在的函数，this就代表那个对象）
Person(String name)
{
this.name =name;

}
Person(String name,int age)
{
this(name);//调用上面的构造函数，用这样的
//this可以用于在构造函数中调用其他的构造函数
注意：只能定义在构造函数的第一行！！！！！！！
因为初始化动作要先执行
（构造）

this.age=age;
}
public boolean compare(Person p)
{
/*
if(this.agep.age)//谁调用this就是谁
return true;
else
return false;
*/
return this.agep.age;
}

static 关键字静态
1.static是一个修饰符，用于修饰成员
2.static修饰的成员被所有的对象所共享
3.static优先于对象存在，因为static的成员随着类的加载就存在了
4.也可以被类访问，------- 类名。静态成员
5.static是共享数据，对象中存储的是特有数据

class Person
{
String name;//成员变量，实例变量
static String country=”CN”;//静态变量，类变量
public void show
{
System.out.println(country+”:”=name);

}
}
class StaticDemo
{
public static void main(String []args)
{
Person p=new Person();
p.name=”HH”;
p.show();
System.out.println(p.country);
System.out.println(Person.country);
}
}
成员变量和静态变量的区别
一．两个变量的生命周期不同，静态的弊端，占地方
1.成员变量随着对象的创建而存在，随着对象的回收而释放
2.静态变量随着类的加载而存在，随着类的消失而消失

二．调用方式不同
成员变量只能被对象调用
静态变量可以被对象调用，还可以被类名调用，建议用类名
三，数据的存储位置不同
成员变量存储在对内存的对象中，也叫对象的特有数据
静态变量的数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据

静态使用的注意事项！！！！！！
1.静态方法只能访问静态成员！！！
2.静态方法中不可以使用this或者super关键字（静态在对象之前）（没有对象咧！）
3.主函数是静态的
class StaticDemo
{
int num=4;
new StaticDemo().show();//因为主函数是静态的，不能直接调用非静态方法和成员，用对象调用
}
public void show()
{
System.out.println(num);
}

主函数：
public：是因为权限必须是最大的
static：不需要对象的，直接用主函数所属类名调用
void：主函数没有具体的返回值
main:函数名，不是关键字，是一个jvm是别的固定的名字
String【】args：这是主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型
//new String[0]
静态区没有this
什么时候用静态？
1.静态变量static int num = 9;
当分析对象中所具备的成员变量的值都是相同的，可以用静态修饰，以后也不要改的那种值，不能改哦！
只要数据在对象中都是不同的，那么就是对象的特有数据，必须存在对象中，是非静态的
如果是相同的数据，对象不需要修改，只需要使用，不需要存储在对象中，定义成静态的

2.静态函数
是否用静态------该函数功能是否访问到对象中的特有数据
简单说，该功能是否需要访问非静态的成员变量
如果要，改功能救是非静态的，
不需要，就可以将功能定义成静态的 /也可以定义成非静态
但是非静态需要被对象调用，而仅为了创建对象调用非静态的
没有访问对象的特有数据的方法，该对象的创建没有意义)/

3.静态代码块-----代码块（独立的代码区间{}）
随着类的加载而执行！！！而且只执行一次

作用：
用于给类进行初始化。(用不到特有数据)
一般来说类里都是静态成员用静态代码块（不用对象）
class StaticCode
{
static int num;
static
{
num=10;
System.out.println(“hahahhaha”)
}
void show()
{
System.out.println(num);
}
}

class StaticCodeDemo
{
public static void main(String[] args)
{
new StaticCodeDemo().show;
}
}

面试。
class Person
{
private String name;

{//构造代码块，，，可以给所有对象初始化
System.out.println(“person run”);
}
Person ()//是给对应的对象进行针对性的初始化
{
name = “xxx”;
}
Person(String name)
{
this.name=name;
}
public void speak()
{
System.out.println(“name:”+name);
}
}

一个非静态方法都没有的类—工具类
没有特有成员，不要创建对象直接用类名调用
该类的方法都是静态的，所以该类不需要创建对象
为了保证不让其他程序创建该类对象，可以将该类的构造函数私有化
class ArrayTool
{
private ArryaTool(){}//私有化构造函数
/** 文档注释！
@param arr （参数的意思）接受一个元素为int类型的数组
@return （返回值的意思）该数组的最大元素值
*/
pubic static int getMax(int [] arr)
{
int maxIndex = 0;
for (int x=1;x<arr.length;x++)
{
if (arr[x]>arr[maxIndex])
maxIndex=x;
}
return arr[maxIndex];
}
}

文档注释：
/**
建立一个用于操作数组的工具类，其中包含常见的对数组操作的函数如：最值，排序等
@ author 张三 (作者)
@version V1.0 (版本)
*/

public class 文件名和类名必须一致当public时
文档注释提供的公有的，私有的不提供

设计模式：对问题行之有效的解决方式
是一种思想
1.单例设计模式
解决的问题：可以保证一个类在内存中的对象唯一性
比如对于多个程序使用同一个配置信息对象时，就要保证该对象的唯一性
如何保证对象的唯一性？
1.不允许其他程序用new创建该类对象
2.在该类中创建个本类实例
3.对外提供一个方法，让其他程序可以获取该对象

步骤
1.私有化该类的构造函数
2.通过new在本类中创建一个本类对象
3.定义一个共有的方法，将创建的对象返回
class Single
{
private static Single s= new Single;//成员变量，私有可控
private Single(){}
public static Single getInstance()
{
return s;
}
}

class SingleDemo
{
public static void main(String [] args)
{
Single s1 =Single.getInstance();
Single s2 =Single.getInstance();
System.out.println(s1==s2);
Test t1=new Test();
Test t2=new Test();
t1.setNum(10);
t2.setNum(20);
System.out.println(t1.getNum());
System.out.println(t2.getNum());
}
}

class Test
{
private int num;
private Test(){};
private static Test t=new Test();
public static Single getInstance()
{
return s;
}

public void setNum(int num)
{
this.num=num;
}
public int getNum()
{
return num;
}
}
成员变量–私有-可控
例子

//懒汉式多线程访问可能不能保证唯一性
class Singel2//类加载进来没有对象，调用getInstance方法时，创建对象。
{ //延迟加载模式，面试
private static Single2 s= null;
Private Single2(){}
public static Single2 getInstance()
{
if(snull)
s=new Single2();
return s;
}
}
Class Single3
{
private static Single3 s=null;
private Single3(){}
public static Single getInstance()
{
if(snull)//提高效率，减少同步代码块的执行
synchronized(Single.class)
{
if(s==null)//延迟加载
s=new Single();
}
}
return s;
}
}
//饿汉试—开发常用
class Singel//类一加载，对象就已经存在
{
private static Single s= new Single;
Private Single(){}
public static Single getInstance()
{
return s;
}
}

继承的好处
1.提高代码的复用性
2.让类与类产生关系
3.给多态产生前提

java中支持单继承，不直接支持多继承，但对c++中的多继承机制进行改良
单继承：一个子类只能有一个直接父类
多继承：一个子类可以有多个直接父类（java中不允许，进行改良）
不直接支持，因为多个父类中有相同成员，是因为会产生调用的不确定性
是通过多实现的方式体现。
java支持多层(多重)继承。
C继承B，B继承A。
就会出现继承体系。

当要使用一个继承体系时，
1，查看该体系中的顶层类，了解该体系的基本功能。
2，创建体系中的最子类对象，完成功能的使用

class Person
{
String name;
int age;
}

class Sdudent extends Person//继承
{
//String name;
//int age;
void study()
{
System.out.println(“student work”);
}
}
class Worker extends Person
{
//String name;
//int age;
void work()
{
System.out.println(“worker work”);
}

}
class ExtendsDemo
{
Student s =new Student();
s.name=”wang”
s.age=20;
s.study();
}

什么时候定义继承呢？

当类与类之间存在着所属关系的时候，就定义继承。xxx是yyy中的一种。 xxx extends yyy

在子父类中，成员的特点体现。
1，成员变量。
2，成员函数。
3，构造函数。

/*
当本类的成员和局部变量同名用this区分。
当子父类中的成员变量同名用super区分父类。
super–父类

this和super的用法很相似。

this:代表一个本类对象的引用。
super：代表一个父类空间。

*/
class Fu
{
private int num = 4;

public int getNum()
{
	return num;
}

}

class Zi extends Fu
{
private int num = 5;

void show()
{
	System.out.println(this.num+"....."+super.getNum());
}

}
（私有的继承不了哦哦哦哦哦哦哦哦哦哦）
子类不能直接访问父类中私有的内容
所以要间接访问，getNum

/成员函数。
/*
当子父类中出现成员函数一模一样的情况，会运行子类的函数。
这种现象，称为覆盖操作。这时函数在子父类中的特性。
函数两个特性：
1，重载。同一个类中。overload
2，覆盖。子类中。覆盖也称为重写，覆写。override

覆盖注意事项：
1，子类方法覆盖父类方法时，子类权限必须要大于等于父类的权限。public private 默认
2，静态只能覆盖静态，或被静态覆盖。

/*
什么时候使用覆盖操作?

当对一个类进行子类的扩展时，子类需要保留父类的功能声明，
但是要定义子类中该功能的特有内容时，就使用覆盖操作完成.
*/
class ExtendsDemo3
{
public static void main(String[] args)
{
// Zi z = new Zi();
// z.show();
NewPhone p = new NewPhone();
p.show();
p.call();
}
}

class honeP
{
void call()
{}
void show()
{
System.out.println(“number”);
}
}

class NewPhone extends Phone
{
void show()
{
System.out.println(“name”);
System.out.println(“pic”);
super.show();
}
}

/*
子父类中的构造函数的特点。

在子类构造对象时，发现，访问子类构造函数时，父类也运行了。
为什么呢？
原因是：在子类的构造函数中第一行有一个默认的隐式语句。 super();
（构造函数没有继承哦）
子类的实例化过程：子类中所有的构造函数默认都会访问父类中的空参数的构造函数。

为什么子类实例化的时候要访问父类中的构造函数呢？
那是因为子类继承了父类，获取到了父类中内容(属性)，所以在使用父类内容之前，
要先看父类是如何对自己的内容进行初始化的。

所以子类在构造对象时，必须访问父类中的构造函数。
为完成这个必须的动作，就在子类的构造函数中加入了super()；语句。

如果父类中没有定义空参数构造函数，那么子类的构造函数必须用super明确要调用
父类中哪个构造函数super（22）；同时子类构造函数中如果使用this调用了本类构造函数时，
那么super就没有了，因为super和this都只能定义第一行。所以只能有一个。
但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数。

注意：supre语句必须要定义在子类构造函数的第一行。因为父类的初始化动作要先完成。

//–>通过super初始化父类内容时，子类的成员变量并未显示初始化。等super()父类初始化完毕后，

class Fu
{
int num ;
Fu()
{
num =10;
System.out.println(“A fu run”);
}
Fu(int x)
{
System.out.println(“B fu run…”+x);
}
}
class Zi extends Fu
{
int num;
Zi()
{
//super();//调用的就是父类中的空参数的构造函数。

	System.out.println("C zi run"+num);
}
Zi(int x)
{
	this();
	//super();

// super(x);
System.out.println("D zi run "+x);
}
}

class ExtendsDemo4
{
public static void main(String[] args)
{
new Zi(6);
}
}
class Demo//extends Object
{
/*

Demo()
{
	super();
	return;
}
*/

}

！！！！！这个程序好好看看！
class Fu
{
Fu()
{
super();
show();
return;
}

void show()
{
	System.out.println("fu show");
}

}
class Zi extends Fu
{
int num = 8;
Zi()
{
super();
//–>通过super初始化父类内容时，子类的成员变量并未显示初始化。等super()父类初始化完毕后，
//才进行子类的成员变量显示初始化。

	System.out.println("zi cons run...."+num);
	return;
}
void show()
{
	System.out.println("zi show..."+num);
}

}
class ExtendsDemo5
{
public static void main(String[] args)
{
Zi z = new Zi();
z.show();
}
}
//zi show …0
//zi cons run
//zi show …8
/*
一个对象实例化过程：
Person p = new Person();
1，JVM会读取指定的路径下的Person.class文件，并加载进内存，
并会先加载Person的父类(如果有直接的父类的情况下).
2，在堆内存中的开辟空间，分配地址。
3，并在对象空间中，对对象中的属性进行默认初始化。
4，调用对应的构造函数进行初始化。
5，在构造函数中，第一行会先到调用父类中构造函数进行初始化。
6，父类初始化完毕后，在对子类的属性进行显示初始化。
7，在进行子类构造函数的特定初始化。
8，初始化完毕后，将地址值赋值给引用变量.

变量第一个首字母小写，第二个单词首字母大写
常量所有字幕都大写，单词不唯一，用下划线连接final double MY_PI=3.14;
成员一旦被final 通常静态
public static final double PI=3.14;

//继承弊端：打破了封装性。
/*
final关键字：
1，final是一个修饰符，可以修饰类，方法，变量。
2，final修饰的类不可以被继承。
3，final修饰的方法不可以被覆盖。
4，final修饰的变量是一个常量，只能赋值一次。
为什么要用final修饰变量。其实在程序如果一个数据是固定的，
那么直接使用这个数据就可以了，但是这样阅读性差，所以它该数据起个名称。
而且这个变量名称的值不能变化，所以加上final固定。

写法规范：常量所有字母都大写，多个单词，中间用_连接。

*/
class Fu
{
void method()
{
//调用了底层系统的资源。
}
}
class Zi extends Fu
{
public static final double MY_PI = 3.14;
static final int x = 7;

void method()
{

// final int x = 9;
// x = 9;
final int NUMBER = 9;

	System.out.println(MY_PI);
}

}

class FinalDemo
{
public static void main(String[] args)
{
System.out.println(“Hello World!”);
}
}

/*
抽象类：
抽象：笼统，模糊，看不懂！不具体。

特点：
1，方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰。
抽象方法必须定义在抽象类中。该类必须也被abstract修饰。
2，抽象类不可以被实例化。为什么？因为调用抽象方法没意义。
3，抽象类必须由其子类覆盖了所有的抽象方法后，该子类才可以实例化。
否则，这个子类还是抽象类。

1，抽象类中有构造函数吗？
有，用于给子类对象进行初始化。

2，抽象类可以不定义抽象方法吗？
可以的。但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。
通常这个类中的方法有方法体，但是却没有内容。

abstract class Demo
{
	void show1()
	{}
	

	void show2()
	{}
}

3，抽象关键字不可以和那些关键字共存?
private 不行子类要覆盖呀
static 不行没有方法体呀
final 不行子类要覆盖呀

4，抽象类和一般类的异同点。
相同点：
抽象类和一般类都是用来描述事物的，都在内部定了成员。
不同：
1，一般类有足够的信息描述事物。
抽象类描述事物的信息有可能不足。
2，一般类中不能定义抽象方法，只能定非抽象方法。
抽象类中可定义抽象方法，同时也可以定义非抽象方法。
3，一般类可以被实例化。
抽象类不可以被实例化。

5，抽象类一定是个父类吗？
是的。因为需要子类覆盖其方法后才可以对子类实例化。

abstract class Demo
{
abstract /抽象/ void show();

}

class DemoA extends Demo
{
void show()
{
System.out.println(“demoa show”);
}
}
class DemoB extends Demo
{
void show()
{
System.out.println(“demob show”);
}
}
*/
abstract class 犬科
{
abstract void 吼叫();
}

class 狗 extends 犬科
{

void 吼叫()
{
	System.out.println("汪汪");
}

}
class 狼 extends 犬科
{
void 吼叫()
{
System.out.println(“嗷嗷”);
}
}

class AbstractDemo
{
public static void main(String[] args)
{
System.out.println(“Hello World!”);
}
}

/*
abstract class AbsDemo
{
abstract void show1();
abstract void show2();
}

当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用
另一种形式定义和表示，就是接口 interface。
*/

//定义接口使用的关键字不是class，是interface.
/*
对于接口当中常见的成员：而且这些成员都有固定的修饰符。
1，全局常量: public static final

2，抽象方法。public abstract

由此得出结论，接口中的成员都是公共的权限.

*/
interface Demo
{
public static final int NUM = 4;

public abstract void show1();
public abstract void show2();

}
//类与类之间是继承关系，类与接口直接是实现关系。
/*
接口不可以实例化。

只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化。
否则，这个子类就是一个抽象类。

class DemoImpl implements /实现/Demo
{
public void show1()
{}

public void show2()
{

}

}

/*
在java中不直接支持多继承，因为会出现调用的不确定性。方法体重复
所以java将多继承机制进行改良，在java中变成了多实现。

一个类可以实现多个接口。

interface A
{
public void show();
}

interface Z
{
public int add(int a,int b);
}

class Test implements A,Z//多实现
{

public int add(int a,int b)
{
	return a+b+3;	
}
/**/
public void show(){}

}

/*
一个类在继承另一个类的同时，还可以实现多个接口。
*/
class Q
{
public void method()
{}
}

abstract class Test2 extends Q implements A,Z
{

}
/*
接口的出现避免了单继承的局限性。

interface CC
{
void show();
}
interface MM
{
void method();
}

interface QQ extends CC,MM//接口与接口之间是继承关系，而且接口可以多继承。
{
void function();
}

class WW implements QQ
{
//覆盖3个方法。
public void show(){}
public void method(){}
public void function(){}
}

class InterfaceDemo
{
public static void main(String[] args)
{

	Test t = new Test();
	t.show();

// DemoImpl d = new DemoImpl();
// System.out.println(d.NUM);
// System.out.println(DemoImpl.NUM);
// System.out.println(Demo.NUM);
}
}

接口是对外暴露的规则
接口是程序的功能扩展
接口降低耦合性
接口可以多实现

/*
抽象类和接口的异同点：

相同点：
都是不断向上抽取而来的。

不同点：
1，抽象类需要被继承，而且只能单继承。
接口需要被实现，而且可以多实现。
2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
接口中只能定义抽象方法，必须由子类去实现。
3，抽象类的继承，是is a关系，在定义该体系的基本共性内容。
接口的实现是 like a 关系，在定义体系额外功能。

犬按功能分：有导盲犬，搜爆犬。

abstract class 犬 //基本功能
{
abstract void 吼叫();
}

//abstract class 导盲
interface 导盲 //额外功能
{
abstract void 导盲();
}

class 导盲犬 extends 犬 implements 导盲
{
public void 吼叫()
{
}

/*
笔记本电脑使用。
为了扩展笔记本的功能，但日后出现什么功能设备不知道。

定义一个规则，只要日后出现的设备都符合这个规则就可以了。
规则在java中就是接口。

*/
interface USB// 暴露的规则。
{
public void open();
public void close();
}

class BookPC
{
public static void main(String[] args)
{
useUSB(new UPan());//功能扩展了。
useUSB(new UsbMouse());
}

//使用规则。
public static void useUSB(USB u)//接口类型的引用，用于接收(指向)接口的子类对象。//USB u= new UPan();
{
	if(u!=null)
	{
		u.open();
		u.close();
	}
}

}
//一年后。------------------------------
//实现规则。

//这些设备和电脑的耦合性降低了。

class UPan implements USB
{
public void open()
{
System.out.println(“upan open”);
}
public void close()
{
System.out.println(“upan close”);
}

}

class UsbMouse implements USB
{
public void open()
{
System.out.println(“UsbMouse open”);
}
public void close()
{
System.out.println(“UsbMouse close”);
}

}

/*
class Mouse
{
}

class BookPC
{
public static void main(String[] args)
{
useMouse(new Mouse());
}
public static void useMOuse(Mouse m)
{
m.open();
}
public static void useMOuse(Mouse m)
{
m.open();
}
}
*/

对象的多态性。

class 动物
{}

class 猫 extends 动物
{}

class 狗 extends 动物
{}

猫 x = new 猫();

动物 x = new 猫();//一个对象，两种形态。

猫这类事物即具备者猫的形态，又具备着动物的形态。
这就是对象的多态性。

简单说：就是一个对象对应着不同类型.

多态在代码中的体现：
父类或者接口的引用指向其子类的对象。

多态的好处：
提高了代码的扩展性，前期定义的代码可以使用后期的内容。

多态的弊端：
前期定义的内容不能使用(调用)后期子类的特有内容。

多态的前提：
1，必须有关系，继承，实现。
2，要有覆盖。

abstract class Animal
{
abstract void eat();

}

class Dog extends Animal
{
void eat()
{
System.out.println(“啃骨头”);
}
void lookHome()
{
System.out.println(“看家”);
}
}

class Cat extends Animal
{
void eat()
{
System.out.println(“吃鱼”);
}
void catchMouse()
{
System.out.println(“抓老鼠”);
}
}

class Pig extends Animal
{
void eat()
{
System.out.println(“饲料”);
}
void gongDi()
{
System.out.println(“拱地”);
}
}

class DuoTaiDemo
{
public static void main(String[] args)
{

// Cat c = new Cat();
// c.eat();
// c.catchMouse();

	Animal a = new Cat(); //自动类型提升，猫对象提升了动物类型。但是特有功能无法s访问。  提高扩展性
						//作用就是限制对特有功能的访问。
						//专业讲：向上转型。将子类型隐藏。就不用使用子类的特有方法。

// a.eat();

	//如果还想用具体动物猫的特有功能。 
	//你可以将该对象进行向下转型。

// Cat c = (Cat)a;//向下转型的目的是为了使用子类中的特有方法。
// c.eat();
// c.catchMouse();

// 注意：对于转型，自始自终都是子类对象在做着类型的变化。
// Animal a1 = new Dog();
// Cat c1 = (Cat)a1;//ClassCastException

	/*
	Cat c = new Cat();

// Dog d = new Dog();

	method(new  Dog());

}

public static void method(Animal a)//Animal a = new Dog();
{
	a.eat();

	if(a instanceof Cat)//instanceof：用于判断对象的具体类型。只能用于引用数据类型判断

// //通常在向下转型前用于健壮性的判断。

	{
		Cat c = (Cat)a;
		c.catchMouse();
	}
	else if(a instanceof Dog)
	{
		Dog d = (Dog)a;
		d.lookHome();
	}
	else
	{
	
	}
	
}
/*
public static void method(Cat c)
{
	c.eat();
}
public static void method(Dog d)
{	
	
}
*/

}

覆盖指发生在函数上哦和变量没关系哦

/*
多态时，
成员的特点：
1，成员变量。
编译时：参考引用型变量所属的类中的是否有调用的成员变量，有，编译通过，没有，编译失败。
运行时：参考引用型变量所属的类中的是否有调用的成员变量，并运行该所属类中的成员变量。
简单说：编译和运行都参考等号的左边。哦了。
作为了解。

2，成员函数(非静态)。
编译时：参考引用型变量所属的类中的是否有调用的函数。有，编译通过，没有，编译失败。
运行时：参考的是对象所属的类中是否有调用的函数。
简单说：编译看左边，运行看右边。

因为成员函数存在覆盖特性。

3，静态函数。
编译时：参考引用型变量所属的类中的是否有调用的静态方法。
运行时：参考引用型变量所属的类中的是否有调用的静态方法。
简单说，编译和运行都看左边。

	其实对于静态方法，是不需要对象的。直接用类名调用即可。

class Fu
{
// int num = 3;
void show()
{
System.out.println(“fu show”);
}

static void method()
{
	System.out.println("fu static method");
}

}

class Zi extends Fu
{
// int num = 4;
void show()
{
System.out.println(“zi show”);
}

static void method()
{
	System.out.println("zi static method");
}

}

class DuoTaiDemo3
{
public static void main(String[] args)
{
Fu.method();
Zi.method();
Fu f = new Zi();//
// f.method();
// f.show();
// System.out.println(f.num);

// Zi z = new Zi();
// System.out.println(z.num);
}
}

/*
内部类访问特点：
1，内部类可以直接访问外部类中的成员。
2，外部类要访问内部类，必须建立内部类的对象。

一把用于类的设计。

分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容。
这时就是还有的事物定义成内部类来描述。

*/
class Outer
{
private static int num = 31;

class Inner// 内部类。
{
	void show()
	{
		System.out.println("show run..."+num);
	}
	/*static void function()//如果内部类中定义了静态成员，该内部类也必须是静态的。
	{
		System.out.println("function run ...."+num);
	}
	*/
}

public void method()
{
	Inner in = new Inner();
	in.show();
}

}

class InnerClassDemo
{
public static void main(String[] args)
{
// Outer out = new Outer();
// out.method();
//直接访问外部类中的内部类中的成员。
// Outer.Inner in = new Outer().new Inner();
// in.show();

	//如果内部类是静态的。 相当于一个外部类

// Outer.Inner in = new Outer.Inner();
// in.show();

	//如果内部类是静态的，成员是静态的。

// Outer.Inner.function();

}

/*
为什么内部类能直接访问外部类中成员呢？
那是因为内部类持有了外部类的引用。外部类名.this

*/
class Outer
{
int num = 3;
class Inner
{
int num = 4;
void show()
{
int num = 5;
System.out.println(Outer.this.num);//了解了解是外部类
//this.num 是内部类
}
}
void method()
{
new Inner().show();
}
}

class InnerClassDemo2
{
public static void main(String[] args)
{
new Outer().method();
}
}

/*
内部类可以存放在局部位置上。
内部类在局部位置上只能访问局部中被final修饰的局部变量。
*/
//因为方法用完释放了，但是对象的引用还在，生命周期不同

class Outer
{
int num = 3;
Object method()
{

	final int x = 9;

	class Inner
	{
		public String toString()
		{
			return "show ..."+x;
		}
	}

	Object in = new Inner();
	return in;//0x0045

// in.show();
}

}

class InnerClassDemo3
{
public static void main(String[] args)
{
Outer out = new Outer();
Object obj = out.method();
System.out.println(obj);

}
/*

class Fu extends Object
{
}
class zi extends Fu
{
}

Fu f = new zi();

Object o = new Fu();
*/

/*
匿名内部类。就是内部类的简写格式。

必须有前提：
内部类必须继承或者实现一个外部类或者接口。

匿名内部类：其实就是一个匿名子类对象。

格式：new 父类or接口(){子类内容}

abstract class Demo
{
abstract void show();
}

class Outer
{
int num = 4;
/*
class Inner extends Demo
{
void show()
{
System.out.println(“show …”+num);
}
}
*/
public void method()
{
//new Inner().show();
new Demo()//匿名内部类。
{
void show()
{
System.out.println(“show …”+num);
}
}.show();
}
}