发展史
1990年是sun公司的一个项目,1994年改名为java,现属于oracle公司。
Java版本
- javaSE:standard edition,标准版,桌面软件,桌游。
- javaME:移动版,发展不怎么好,被Android用了然后带飞了。
- javaEE:企业版,一般用其做大型系统,大型网站。
java优点
一次编写,处处运行,在不同系统上安装java虚拟机(JVM)即可使用,且jvm不跨平台,各个系统都可以使用。所以java是跨平台语言。
java相关工具认识
JDK:java development kit ,java开发者工具。(=JRE+运行环境工具)
JRE:java runtime environment, java运行环境,包含 java虚拟机。(只能运行java程序,但不能开发。)(=JVM+核心类库)
JVM:java virtual machine, java虚拟机,相当于在操作系统上模拟了一个cpu去运行java相关的东西。
java跨平台核心是因为JVM
安装jdk(java开发者包)
- 百度搜索jdk12,找到下载地址
- 下载对应的版本,下载exe后缀的
- 双击安装jdk
- 记住安装的路径,
- 配置环境变量(不区分大小写)
我的电脑-右键-属性-环境变量
- java_home :需要自己新建,写java的jdk的路径。
- path :写到jdk下的bin目录,此条必须写,因为执行程序时会 在里面找相应的程序。
- classPath: .;java的lib目录(;前写的.代表自己写的类,;后写别人写得类的路径。)
例如: (%包住代表相对应用)
- dos下输入 java -version 显示版本表示安装成功
删除jdk
- 删除java的安装目录(删除jdk的包)
- 删除java_home(此电脑-属性-高级设置-环境变量)
- 删除path下关于Java的目录
- dos窗口输入 java -version 出现 java 不是内部或者外部命令,也不是可运行的程序或批处理文件
helloworld代码初实现
- 编译软件编译
public class Hello{
public static void main(String[] args){
System.out.print("hello,world");
}
}
- dos窗口编译运行
- 使用javac编译java文件,会生成一个class文件
- 再通过java 运行class文件,此时class文件不用写后缀
可能遇到的问题:
-java大小写敏感
-尽量使用英文
-文件名和class后的名字必须保证一致
-符号必须使用英文
java注释
- 单行注释 //
- 多行注释/* */
- 文档注释 /** */ 可以识别的
标识符
- 又名关键字,是系统定义好的。(所以不能用这些再起名字了)
如 public 、class、 static、 viod、 - 、标识符是大小写敏感的
- 可以使用中文命名,但一般不建议这样。
- 所有标识符都应该以字母A-Z,a-z,美元符$,或者下划线开始。
数据类型
- 强类型语言: 要求变量的使用要严格符合规定,所有变量必须先定义后才能使用。java、 c++
- 弱类型语言: 变量符合规定就行了,没有这么严格。
- java的两大类数据类型:
3.1 基本类型:
数值类型(整数类型(byte、short、int、long)、浮点类型(float(四个字节)、double(占8个字节))、字符类型(char,占两个字节)),布尔类型(boolean,只占一个位,只有true,false两个取值)
例子: int num1=10;
byte num2=20;
short num3=30;
long num4=30L; //long类型要在数字后面加个L
float num5=50.1F; // 默认为double类型,所以加个F指明为float类型
double num6=3.1415926;
char name=‘张’ ; // 字符类型 只能是一个字。或者单个的字母
String names=" ahnasubcnu" //String不是关键字,是一个类。
boolean flag=true;
boolean flag=false;
3.2 引用类型:类、接口、数组
小科普:什么是字节
1. 位:是计算机 内部数据 存储 的最小单位,11001100是一个八位二进制数。bit
2. 字节:是计算机中 数据处理 的基本单位,习惯上用B来表示。byte
3. 1B=8bit (一个字节等于八位数)
4. 字符:使之计算机中使用的字母、数字、字和符号。
5. 电脑32位和64位指的是电脑的寻址能力。
6. 1byte=8bit ; 1024byte=1kb;1024kb=1m;1024m=1G
7. 1位 只有0和1两种情况,通常以byte为单位(8位)
8. 1 short = 2 byte; 1 int =4 byte; 1 long =8 byte= 8* 8 =2^64bit
9. 1 float =4 byte;1 double =8 byte;
10. 一个byte有2^8=256个可能性,正负开为[-128,127],即为byte的取值范围。
3.2 **引用类型**:类、接口、数组
///进制问题
1. 二进制:数字前加ob ob11=2
2. 八进制:数字前加o o11=9
3. 十六进制:数字前加ox ox11=16^1+16^0=17 A~F表示10到15
常量、变量
- java变量是程序中最基本的存储单位,包括变量名、变量类型和作用域。/数据类型 变量名 =值;
- 声明变量是一条完整的语句,每一个声明必须以分号结束。
变量的分类:
- 局部变量:只写在方法里面。必须进行初始化。
- 实例变量:作用域更大,写在类里面,方法的外面,从属于(对象)类,通过类才能使用。如果不自行初始值,默认为0、0.0、false,null.
- 类变量:和实例变量一样,前面加个static,从属类,static为修饰符,不存在先后顺序
- 常量:初始化后不能再改变的值,final 常量名=值;常量一般用大写字符。声明一个常量:static final double PI=3.14;(声明一个常量)
- 变量存在于内存中,程序结束,计算机关机,变量失效,写入磁盘中的东西才能永久保存。
- 变量的命名规范:
- 所有变量、方法、类名要见名知意
- 类成员变量和局部变量:首字母小写和驼峰原则(除了第一个单词以外,后面的单词首字母大写(lastName、monthSalary))
- 常量:大写字母和下划线:MAX_VALUE
- 类名:首字母大写和驼峰原则Man、DoodMan
- 方法名:首字母小写和驼峰原则run()、runRun()
即变量名,方法名首字母小写,类名首字母大写 都驼峰原则。
运算符
- 算术运算符:+ - * /(取余) %(取模) ++(自增) --(自减)//自增自减属于一元运算符
- 赋值运算符:=
- 关系运算符;> < >= <= ==(等于) !=instanceof //关系运算符返回结果只有(true、false)
- 逻辑运算符: && || !(与或非 and or !)
- 位运算符:& | ^ >> << >>>
A= 0011 1100
B= 0000 1101
---------------------
//位运算
A&B 0000 1100 //两个位都为1时,结果才为1
A|B 0011 1101 //两个位都为0时,结果才为0
A^B 0011 0001 //两个位相同为0,相异为1
~B 1111 0010 //取反操作
/左移右移相对来说是底层运算,所以效率极高。
<< *2(左移*2)
>> /2(右移/2)
2*8=16 2*2*2*2=16
0000 0000 0
0000 0001 1
0000 0010 2
0000 0011 3 0000 0101 5
0000 0100 4 0000 0110 6
0000 1000 8 0000 0111 7
0001 0000 16
--------------------------------
//字符串连接符 +
int a =10;
int b=20;
System.out.println(a+b+"");//“”代表空字符串,因为字符串在后面,会先进行计算 30
System.out.println(""+a+b);//因为字符串在前面,会先进行字符串的拼接 1020
System.out.println(""+(a+b));//因为加了括号,会优先运算括号里面的。 30
- 条件运算符: ? :(因为涉及三个变量,所以叫三元运算符)
X ? Y : Z//如果X==true,则结果位Y,否则为true;
//x必须是布尔类型的值或者表达式
--------------------
public class demo05 {
public static void main(String[] args) {
boolean x= true;
int y= 2;
int b =20;
System.out.println(x ? y : b);
}
}
---------------------------
public class demo05 {
public static void main(String[] args) {
int score =50;
String type =score<60 ? "不及格":"及格";
System.out.println(type);
}
}
- 扩展赋值运算符:+= 、-= 、*= 、/=
int a=10;
int b=20;
a+=b;//a=a+b
a-=b;//a=a-b
特别说明:短路运算:a&&b ,若a是错误,则不会执行b。
初识math
- 幂运算2^3
很多运算会使用一些工具类来操作
double pow =Math.pow(2,3);
System.out.println(pow);
包机制
- 包的本质就是文件夹。
- 一般用公司域名倒置作为包
JavaDoc
javadoc命令是用来生成自己API文档的。类似与java的API文档
java程序的运行机制
- 计算机的高级语言编程类型:
- 编译型:有一个负责翻译的程序,翻译成计算机能看懂的语言。
解释型:对速度要求不高,边执行边解释。 - java既属于编译型又属于解释型。java先编译后解释。
- 程序运行机制:javac中的c就是class的意思, 可以把java文件编译成class文件,再通过解释器告诉操作系统进行操作。
用户交互Scanner
说明:实现程序和人的交互,可以通过Scanner类获取用户的输入。通过java.util.Scanner包。
基本语法:
Scanner s = new Scanner(System.in);
Scanner属于类,有两个对象:
//next()不能得到带有空格的字符串,后者可以。
通过Scanner类的next()与nextLine()方法获取输入的字符串,在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。
package scanner;
import java.util.Scanner;
public class demo03 {
public static void main(String[] args) {
Scanner scanner =new Scanner(System.in);//创建一个Scanner类型的scanner容器,来接收键盘的输入。
System.out.println("请输入数据:");//提示用户输入数据
String str =scanner.nextLine();//程序在此时停下,直到输入变量保存到变量类型为String的str中去。
System.out.println("输出的内容为:"+str);//
scanner.close();
}
}
顺序结构
- java的基本结构就是顺序结构,除非特别指明那个,一般都是一行一行执行。
- 顺序结构是最简单的算法结构。
选择结构
- if单选择结构
if(布尔表达式){
//如果为true执行的语句;
}
- if双选择结构
if(布尔表达式){
表达式为true执行的语句;
}else{表达式为true执行的语句;}
- if多选择结构
if(布尔表达式){表达式为true执行的语句;}
else if(布尔表达式){表达式为true执行的语句;}
else if(布尔表达式){表达式为true执行的语句;}
else if(布尔表达式){表达式为true执行的语句;}
else if(布尔表达式){表达式为true执行的语句;}
else if(布尔表达式){表达式为true执行的语句;}
else{表达式为true执行的语句;}
package struct;
import java.util.Scanner;
public class ifDemo02 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入内容:");
int s = scanner.nextInt();
if(s==100){
System.out.println("恭喜,满分");
} else if(s<100 && s>=90){
System.out.println("A级");
} else if(s<90 && s>=80){
System.out.println("B级");
} else if(s<80 && s>=70){
System.out.println("C级");
} else if(s<70 && s>=60){
System.out.println("D级");
} else if(s<60 && s>=0) {
System.out.println("不及格");
} else{
System.out.println("不合法");
}
System.out.println("end");
scanner.close();
}
}
//按顺序只要一个为真就直接跳出程序。
- 嵌套的if结构
- switch多选择结构
#####switch case 语句判断一个变量与一系列值中某个值是否相等,每个值称为一个分支
switch(表达式){
case value:
输出语句;
break;//可选
case value:
输出语句;
break;//可选
default:
//默认输出
}
public class IfDemo03 {
public static void main(String[] args) {
Scanner scanner =new Scanner(System.in);
System.out.println("请输入:");
String s = scanner.nextLine();
switch(s){
case "Hello":
System.out.println("你好");
break;
case "100":
System.out.println("满分");
break;
default:
System.out.println("end");
break;
}
System.out.println("end");
scanner.close();
}
///break是执行完跳出循环,
///default是默认,当都不符合case条件时,执行default语句。
//break和default都不是必须写的内容。
//case穿透,不写break会把剩下的case执行输出一遍。所以一般都要配break.
循环结构
- while循环
while(布尔表达式){
//循环内容
}
//只要表达式为true,循环就会一直执行,大多数情况下需要一个让表达式失效的方式来结束循环。
//
package struct;
public class WhileDemo01 {
public static void main(String[] args) {
//输出1-100
int i =0;
while(i<100){
i++;
System.out.println(i);
}
}
}
package struct;
public class WhileDemo02 {
//计算1+2+3+……+100
public static void main(String[] args) {
int i =0;
int sum =0;
while(i<100){
i++;
sum =sum +i ;
System.out.println(i+"个数相加的和为:"+sum);
}
}
}
- do while 循环:即使不满足条件,也至少执行一次。
do{
//代码语句
}whlie(布尔表达式)
package struct;
public class DoWhileDemo01 {
public static void main(String[] args) {
int i=100;
int sum =0;
do {
sum = sum + i;
i++;
} while(i<100);{
System.out.printf(i+"个数和和为:"+sum);
}
}
}
- for循环
- for循环使一些循环结构变得简单。
- for循环是支持迭代的一种通用结构,是最有效最灵活的循环结构。
- for循环的执行次数是在执行前就确定的。
- for循环说明:
最先执行初始化步骤可以声明一种类型,但可初始化一个或多个循环变量体,也可以是空语句。然后检测布尔表达式,如果为rue,则执行循环体,否则,循环终止,开始执行循环体后面的语句,执行一次循环后,更新循环控制变量,再次检测布尔表达式,循环执行上面的过程。
for(初始化; 布尔表达式; 更新){
//循环体
}
//根据初始值先判断是否满足布尔表达式,若满足则执行循环体,更新控制语句,否则跳出循环。
for( ; ; ){}
//代码可以存在,但是是死循环
。
- 增强for循环
for(声明语句:表达式)
{
//代码句子
}
//声明语句:声明新的局部变量,该变量的类型必须和数组元素的类型相匹配,其值与数组元素的值相等。
//表达式:表达式是要访问的数组名,或者是返回值为数组的方法。
package struct;
//增强for循环
public class ForDemo06 {
public static void main(String[] args) {
int [] number={10,20,30,40,50};//定义了一个数组
for(int i =0;i<5;i++)
{
System.out.println(number[i]);
}
System.out.println("=========================");
for(int x :number ){//增强for循环,遍历数组的元素,直接把number每一项的值赋值给x
System.out.println(x);
}
}
}
break&contine
//break用于强制性退出循环,不执行循环中剩余语句。用在任何循环结构的部分,直接跳出循环。
//coutinue,用于终止某次循环过程。即跳出循环体中尚未执行的部分,接着进行下一次是否执行循环体的判断。
public interface BreakDemo {
public static void main(String[] args) {
int i=0;
while(i<10){
i++;
if(i==5)
continue;//碰到i=5,跳出该次循环,判断是否执行下一次循环。
System.out.println(i);
}
System.out.println("end");
}
}
public interface BreakDemo {
public static void main(String[] args) {
int i=0;
while(i<10){
i++;
if(i==5)
break;//碰到i=5,跳出循环体
System.out.println(i);
}
System.out.println("end");
}
}
一些练习:
package struct;
计算0到100之间奇数和偶数的和
public class ForDemo02 {
public static void main(String[] args) {
int osum =0;//定义偶数的和
int jsum =0;//定义奇数的和
//for(初始化、判断语句、控制语句){循环体//此时用if进行判断}
for(int i=0;i<=100;i++){
if(i%2==0){
osum=osum+i;
}else{
jsum=jsum+i;
}
}
System.out.println(osum);
System.out.println(jsum);
}
}
package struct;
//用for循环输出1-1000之间能被5整除的数,并且每行输出三个。
public class ForDemo03 {
public static void main(String[] args) {
for(int i=1;i<=1000;i++){
if(i%5==0){
System.out.print(i+"\t");//先找出能被5整除的数字,不让换行输出
}
if(i%15==0){
System.out.println();//找出能被15整除的数,换行出
//等价于System.out.print("\t");
}
}
}
}```
package struct;
//99乘法表 自己写
public class ForDemo05 {
public static void main(String[] args) {
for(int i =1;i<=9;i++){//j代表行,i代表列
for(int j =1;j<=i;j++){//j代表行,i代表列
//由行控制列,所以外面是行,里面是列
System.out.print(j+"*"+i+"="+(j*i)+"\t");
}
System.out.println();
}
}
}
主要思想:
1.先打印第一行
2.我们把固定的1再用循环包起来
3.去掉重复项,i<j
4.调整样式
package struct;
//99乘法表
public class ForDemo04 {
public static void main(String[] args) {
for(int j = 1; j <= 9; j++){
for (int i = 1; i <= j; i++) {//i是列,j是行
System.out.print(i+"*"+j+"="+(j*i)+"\t");
}
System.out.println();
}
}
}
//先用一个变量打印出一行或一列,用变量调试。
方法
- 方法是语句的集合,在一起执行一个功能。本质上就是函数
- 方法的命名规则:首字母小写,驼峰原则
package method;
public class Demo01 {
//main方法
//void代表返回类型为空
public static void main(String[] args) {
int sum =add(1,2);
System.out.println(sum);
}
//加法,类的名字为add,类型为int
public static int add (int a,int b){
return a+b;
}
}
- 设计方法的原则:一个方法只完成一个功能,便于后期的拓展。即原子性。
方法定义及调用
1. 修饰符 返回值类型 方法名(参数类型 参数名){
2. 方法体
3 .……
4 return 返回值
5. }
方法的定义:
//修饰符:可选,告诉编译器如何调用该方法,定义该方法的访问类型,如public
//返回值类型:方法可能会有返回值,如不需要返回值,关键字为void
//方法名:自己起的名字
//参数:分为实参和形参。多个参数用,隔开
//方法的具体内容。
//方法的调用
对象名.方法名(实参列表)
1.有返回值时调用
2.方法返回值时Void时,方法调用是一条语句。
package method;
public class Demo02 {
public static void main(String[] args) {
int max=max(3,4)//方法调用,把方法的值赋值给max
System.out.println(max);//输出值
}
//修饰符 返回值类型 方法名(形参类型 形参名字)
public static int max(int num1,int num2){
int result=0;
if(num1>num2){
result =num1;
}if(num1<num2){
result=num2;
} else{
System.out.println("num1<num2");
return 0;//终止方法
} return result;
}
}
方法重载
1.方法名一样,但参数列表必须不同(可以是类型不同,个数不同,参数排列顺序不同等),方法的返回值类型可以相同可以不同。仅仅返回类型不同不足以成为方法的重载。(容易出现笔试)
2. 实现理论:
方法名称相同时,编译器会根据调用方法的参数个数、参数类型等去逐个匹配,以选择对应的方法,如果匹配失败,则编译器报错。
可变参数
public static int max(int num1,int num2){//可变参数,max(int num1,double...num2),int为普通参数,double类型的为可变参数,即可以有很多个double类型的参数。
int result=0;
if(num1>num2){
result =num1;
}if(num1<num2){
result=num2;
} else{
System.out.println("num1<num2");
return 0;//终止方法
} return result;
- 一个方法中只能指定一个可变参数,它必须是方法的最后一个参数,任何普通参数必须在它之前声明。
- 声明方式: 在指定参数类型后加一个省略号
递归
A方法调用A方法。自己调用自己。
package method;
/求阶乘
public class Demo04 {
public static void main(String[] args) {
System.out.println(diGui(4));//4的阶乘
}
public static int diGui(int n){
if(n==1){
return 1;
}else{
return n*diGui(n-1);
}
}
}
- 递归会有边界,即一定会进行到底。
- 先算4->3->2->1 结果在从1返回来
- 基数比较大大事,占内存效率低,不一定跑起来。会影响机器的性能。
//计算器
public class test {
public static void main(String[] args) {
try {
Scanner input = new Scanner(System.in);
System.out.print("请输入第一个数字:");
double nuber1 = input.nextDouble();
System.out.print("请输入第二个数字:");
double nuber2 = input.nextDouble();
System.out.print("请输入运算符:(+、-、*、/)");
String oprate=input.next();
double result = 0;
switch (oprate) {
case "+":
result = nuber1 + nuber2;
break;
case "-":
result = nuber1 - nuber2;
break;
case "*":
result = nuber1 * nuber2;
break;
case "/":
if (nuber2 == 0) {
System.out.print("除数不能为0");
} else {
result = nuber1 / nuber2;
}
break;
}
System.out.print("结果是:" + result);
} catch (Exception e) {
System.out.println("输入有误");
}
}
}
==================================
基本思路
1.写4个方法:加减乘除
2.利用循环+switch进行用户交互
传递需要操作的两个数
输出结果
数组
一组数,相同类型,先后次序,通过下标访问。下标从0开始,数组一旦被创建,大小就不可以改变了。数组中的元素可以是基本类型,也可以是引用类型。
- 数组的声明与创建
int [] nums;//定义了数组,数组名为nums
nums = new int[10]// 创建一个数组
nums[0]=1; //给数组赋值
声明创建一个数组
int [] nums = new int[10];
///
获取数组长度:array.length
- 数组使用
package method;
public class ArrayDemo07 {
public static void main(String[] args) {
//打印全部的数组元素
int[] array = {1, 2, 76, 84, 5};
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]);
}
System.out.println();
//计算所有元素的和
int sum = 0;
for (int i = 0; i < array.length; i++) {
sum = sum + array[i];
}
System.out.print(sum);
System.out.println();
//查找最大元素
int max = 0;
for (int i = 0; i < array.length; i++) {
if(array[i]>max){
max=array[i];
}
}
System.out.println(max);
}
}
package method;
public class ArrayDemo07 {
public static void main(String[] args) {
int[] arrays={1,23,45,56,67,78,43};
printArray(arrays);
}
//打印数组元素
//主要说明数组可以分装成类的参数
public static void printArray(int[] arrays){
for(int i=0;i< arrays.length;i++){
System.out.print(arrays[i]);
}
System.out.println("");
}
- 多维数组:定义二维数组
int [ ] [ ] array={{1,2,3,4,5},{1,2,3,4,5}} - arrays类
数组中本身没有什么方法,数组中有一个Arrays类,包含操作数组方法的各种元素。例如: array.sort(数组名)会排序,sort是array中的一种方法。 - 稀疏数组(了解概念即可,不怎么用)
- 冒泡排序:是一种排序算法。每两个进行一次比较。时间复杂度为o(n2).
package method;
import java.util.Arrays;
public class Demoo7 {
public static void main(String[] args) {
int[] a = {2, 34, 5, 6, 78, 90, 55, 45, 23, 12};
int[] sort = sort(a);//将数组a调用我们写的方法。
System.out.println(Arrays.toString(sort));//将其转化为字符串输出
}
//1.比较数组中两个相邻的元素,第一个数比第二个大,则交换顺序
public static int[] sort(int[] array) {
//临时变量
int tem = 0;
//外层循环,判断要走都少次
for (int i = 0; i < array.length - 1; i++) {
//内层循环,比较判断两个数,判断出来,交换位置。
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j] > array[j + 1]) {
tem = array[j];
array[j] = array[j + 1];
array[j + 1] = tem;
}
}
}
return array;
}
}
- 初始数组为空时,在栈里
- 给数组分配空间是,在堆里,通过new关键字
- 数组的三种初始化(赋值)状态:
1.静态初始化
int[] a = {1,2,3};
Man[] mans = {new Man(1,1) , new Man(2,2)};
2.动态初始化
int[] a = new int[2];
a[0]=1;
a[1]=2;
3.数组的默认初始化
数组是引用类型,它的元素相当于类的实例变量,因此数组一经分配空间,其中的每个元素也被按照实例变量同样的方式被隐式初始化。
数组的使用
For-Each循环
public class Demo09_Array {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
//JDK1.5,没有下标
for (int array : arrays) {
System.out.println(array);
}
}
}
数组作方法入参
public class Demo09_Array {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
printArray(arrays);
}
//打印数组元素
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+" ");
}
}
}
数组作返回值
public class Demo09_Array {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
int[] reverse = reverse( arrays);
printArray(reverse);
}
//反转数组
public static int[] reverse(int[] arrays){
int[] result = new int [arrays.length];
//反转的操作
for (int i = 0,j=result.length-1; i < arrays.length; i++,j--) {
result[j] = arrays[i];
}
return result;
}
//打印数组元素
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+" ");
}
}
}
封装
- 程序设计原则;高内聚低耦合。
- 将数据封装起来,只暴露给外界接口。
- 封装主要是针对属性的。在属性前面加关键词 private
- 把属性用 private修饰
- 对私有属性的操作 通过公共的get/set方法完成。
//类中只有属性和方法
public class Student {
//类 private: 私有
//属性私有
private String name; //名字
private int id; //学号
private char sex; //性别
private int age;
//提供一些可以操作这个属性的方法!
//提供——public的get. set方法
//get获得这个数据
public String getName(){
return this.name;
}
//set给这个数据设置值
public void setName(String name){
this.name = name;
}
//alt + insert
public int getAge() {
return age;
}
public void setAge(int age) {
if(age <0 || age > 120){
this.age = 3;
}else {
this.age = age;
}
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
}
- 封装的优点
提高程序的安全性,保护数据.
隐藏代码的实现细节
统一接口
系统可维护增加了
继承
- 继承的本质是对某一批类的抽象,从而实现对现实世界更好的建模。
- extands的意思是“扩展”。子类是父类的扩展。
- JAVA中类只有单继承,没有多继承!
- 被final修饰的类不能被继承。
- 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
- 继承关系的俩个类,一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
- 子类和父类之间,从意义上讲应该具有"is a"的关系.
- object类
java中的所有类都直接或间接继承Object类 - super
- super注意点:
- super调用 父类的构造方法,必须在构造方法的第一个
- super 必须只能出现在子类的方法或者构造方法中!
- super和 this 不能同时调用构造方法!
- Vs this:
- 代表的对象不同: this 本身调用者这个对象 super:代表父类对象的应用
- 前提 this:没有继承也可以使用 super:只能在继承条件才可以使用
- 构造方法 this() ; 本类的构造 super():父类的构造!
// 子类维承了父类,就会拥有父类的全部方法!
public class Student extends Person{
public Student() {
//隐藏代码:调用了父类的无参构造
super(); // 调用父类的构造器,必领要在子类构造器的第一一行
System.out.println("Student无参执行了");
}
public Student(String name) {
this .name = name ;
}
private String name = "qinjiang" ;
public void print(){
System.out.println("Student");
}
public void test1(){
print();//Student
this.print();//Student
super.print();//Person
}
}
public class Person {
//一个类即使什么都不写,它也会存在个方法
//显示的定义构造器
protected String name ="kuangshen";
int age;
//alt+ insert
//1.使inew关键字, 本质是在调用构造器
//2.用例初始化值
public Person(){
System.out.println("Person");
}
//有参构造:一旦定义 了有参构造。无参就必须显示定义
public Person(String name){
this.name = name ;
}
public void print(){
System.out.println("Person");
}
}
方法重写
父类静态方法
public class Demo04_A extends Demo04_B{
public static void test(){
System.out.println("A==>test()");
}
}
//重写都是方法的重写,和属性无关
public class Demo04_B {
public static void test(){
System.out.println("B==>test()");
}
}
public class Applications {
public static void main(String[] args) {
//Demo04
//方法的调用只和左边,定义的数据类型有关
Demo04_A a = new Demo04_A();
a.test();//A==>test()
//父类引用指向引用
Demo04_B b = new Demo04_A();
b.test();//B==>test()
}
}
父类非静态方法
public class Applications {
public static void main(String[] args) {
//Demo04
/*
静态方法和非静态方法区别很大
静态方法:方法的调用只和左边,定义的数据类型有关
非静态方法:重写,父类方法只能是public
*/
Demo04_A a = new Demo04_A();
a.test();//A==>test()
//父类引用指向引用
Demo04_B b = new Demo04_A();//子类重写了父类的方法
b.test();//A==>test()
}
}
//重写都是方法的重写,和属性无关
public class Demo04_B {
public void test(){
System.out.println("B==>test()");
}
}
public class Demo04_A extends Demo04_B{
@Override
public void test() {
System.out.println("A==>test()");
}
}
- 重写:需要有继承关系,子类重写父类的方法!
- 方法名必须相同
- 参数列表列表必须相同
- 修饰符:范围可以扩大但不能缩小:public>Protected >Default>private
- 抛出的异常:范围,可以被缩小,但不能扩大: ClassNotFoundException --> Exception(大)
- 重写,子类的方法和父类必要一 致;方法体不同!
- 为什么需要重写:
- 父类的功能,子类不一定需要, 或者不一定满足!
- Alt +Insert ;---->override;
多态
- 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
- 一个对象的实际类型是确定的,但可以指向对象的引用的类型有很多
- 多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
- 注意:多态是方法的多态,属性没有多态性。
- 多态注意事项:
- 多态是方法的多态,属性没有多态
- 父类和子类,有联系 类型转换异常! ClassCastException!
- 存在条件: 继承关系,方法需要重写,父类引用指向于类对象! Father f1 = new Son();
- 不能进行多态的方法:
static 方法,属于类,它不属于实例
final常量;
private 方法;
- instanceof:(类型转换)引用类型, 判断一个对象是什么类型~
public class Applications {
public static void main(String[] args) {
Object object = new Student();
//System. out . println(X instanceof Y);//能不能编译通过! X,Y之间要存在父子关系
//System. out . println(X instanceof Y);// X是Y之的子类,true
System.out.println(object instanceof Student); //true
System.out.println(object instanceof Person); //true
System.out.println(object instanceof Object); //true
System.out.println(object instanceof Teacher); //False
System.out.println(object instanceof String); //False
System.out.println("===========================");
Person person = new Student();
System.out.println(person instanceof Student); //true
System.out.println(person instanceof Person); //true
System.out.println(person instanceof Object); //true
System.out.println(person instanceof Teacher); //False
//System.out.println(person instanceof String); //不能通过编译
System.out.println("===========================");
Student student = new Student();
System.out.println(student instanceof Student); //true
System.out.println(student instanceof Person); //true
System.out.println(student instanceof Object); //true
//System.out.println(student instanceof Teacher); //不能通过编译
//System.out.println(student instanceof String); //不能通过编译
}
}
- 转换
父类转子类
public class Application {
public static void main(String[] args) {
//类型之间的转化:父子
//高 低
Person obj = new Student();
//student将这个对象转换为Student类型,我们就可以使lstudent类型的方法了!
((Student) obj).go();
}
}
子类转父类
public class Application {
public static void main(String[] args) {
//类型之间的转化:父 子
//子类转换为父类,可能丢失自己的本来的一些方法!
Student student = new Student();
student.go();
Person person = student;
}
}
- 多态总结
- 父类引用指向子类的对象
- 把子类转换为父类,向上转型;
- 把父类转换为子类,向下转型;强制转换
- 方便方法的调用,减少重复的代码!简介
- 封装、继承、多态! 抽象类,接口
static
public class Student {
//2:赋初值~
{
System.out.println("匿名代码块");
}
//1 :只执行一次~
static {
System.out.println("静态代码块");
}
//3
public Student() {
System.out.println("构造方法");
}
public static void main(String[] args) {
Student student = new Student();
System.out.println("==========");
Student student2 = new Student( );
}
}
//静态导入包~
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class demo01 {
public static void main(String[] args) {
System.out.println(random());
System.out.println(PI);
}
}
抽象类
- abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方;如;果修饰类,那么该类就是抽象类。
- 抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
- 抽象类,不能使用new关键字来创建对象, 它是用来让子类继承的。
- 抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
- 子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法, 否则该子类也要声明为抽象类。
//约束有人帮我们实现~
public abstract class Action {
//abstract, 抽象方法,只有方法名字,没有方法的实现!
public abstract void run();
public void go(){
System.out.println("Action==>go()");
}
//1. 不能new这个抽象类,只能靠子类去实现它;约束!
//2. 抽象类中可以写普通的方法~
//3. 抽象方法必须在抽象类中~
//抽象的抽象:约束~
//思考题? new,存在构造器么?
//存在的意义抽象出来~ 提高开发效率
}
public class A extends Action{
//必须实现父类的抽象方法,除非其本身也是抽象类
@Override
public void run() {
System.out.println("A==>run()");
}
}
接口
- 普通类:只有具体实现
- 抽象类:具体实现和规范(抽象方法)都有!
- 接口:只有规范! 自己无法写方法~专业的约束!约束和实现分离:面对接口编程
- 接口就是规范,定义的是一组规则,体现了现实世界中“如果你…则必须能.的思想。如果你是天使,则必须能飞。如果你是汽车,则必须能跑。如果你好人,则必须干掉坏人;如果你是坏人,则必须欺负好人。
接口的本质是契约,就像我们人间的法律一样。制定好后大家都遵守。
oo的精髓,是对对象的抽象,最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言(比如c++. java、 c#等) ,就是因为设计模式所研究的,实际上就是如何合理的去抽象。
public interface UserService {
//interface定义的关键字,按口都需 要有实现类
//常量~ pubsic static final,一般不在接口中定义常量
int AGE = 99;
//按口中的所有定义的方法其实都是抽象的public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
public interface TimeService {
void timer();
}
//抽象类: extends~
//类可以实现接口implements 按口
//实现了按口的类,就需要重写接口中的方法~
//多继承~利用接口实现多继承
public class UserServiceImpl implements UserService, TimeService {
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
- 接口总结
- 方法public abstract
- 常量public static final
- 接口不能被实例化,接口中没有构造方法
- implements 可以实现多个接口
- 必须要重写接口中的方法~
内部类
- 内部类就是在一个类的内部在定义一个类,比如,A类中定义一个B类,那么B类相对A类来说就称为内部类,而A类相对B类来说就是外部类了。
- 成员内部类
public class Outer {
private int age = 10;
public void out(){
System.out.println("这是外部类的方法");
}
public class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
public void getAge(){
System.out.println(age);
}
}
}
public class Applications {
public static void main(String[] args) {
//demo09
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.getAge();
inner.in();
outer.out();
}
}
- 静态内部类
- 局部内部类
//局部内部类
public void method(){
class Inner1{
public void in1(){
}
}
}
- 匿名内部类
异常
- 实际工作中,遇到的情况不可能是非常完美的。比如:你写的某个模块,用户输入不一定符合你的要求、你的程序要打开某个文件,这个文件可能不存在或者文件格式不对,你要读取数据库的数据,数据可能是空的等。我们的程序再跑着,内存或硬盘可能满了。等等。
- 软件程序在运行过程中,非常可能遇到刚刚提到的这些异常问题,我们叫异常,英文是:Exception,意思是例外。这些,例外情况,或者叫异常,怎么让我们写的程序做出合理的处理。而不至于程序崩溃。
- 异常指程序运行中出现的不期而至的各种状况,如:文件找不到、网络连接失败、非法参数等。
- 异常发生在程序运行期间,它影响了正常的程序执行流程。
- 要理解Java异常处理是如何工作的,你需要掌握以下三种类型的异常:
- 检查性异常:最具代表的检查性异常是用户错误或问题引起的异常,这是程序员无法预见的。例如要打开一个不存在文件时,一个异常就发生了,这些异常在编译时不能被简单地忽略。
- 运行时异常:运行时异常是可能被程序员避免的异常。与检查性异常相反,运行时异常可以在编译时被忽略。
- 错误ERROR:错误不是异常,而是脱离程序员控制的问题。错误在代码中通常被忽略。例如,当栈溢出时,一个错误就发生了,它们在编译也检查不到的。
- 异常体系结构
- Java把异常当作对象来处理,并定义一个基类java.lang.Throwable作为所有是常的超类。
- 在Java API中已经定义了许多异常类,这些异常类分为两大类,错误Error和异常Exception。
异常处理框架
public class Demo1 {
public static void main(String[] args) {
int a=1;
int b=0;
//假设要捕获多个异常:从小到大!
try { //try监控区域
System.out.println(a/b);
} catch (Error e){ //catch(想要航获的异常类型! )捕获异常
System.out.println("Error");
} catch (Exception e){
System.out.println( "Exception");
} catch (Throwable t){
System.out.println("Throwable");
} finally { //处理普后工作
System.out.println( "finally");
}
//finally可以不要finally,假设IO, 资源,关闭!
}
public void a(){
b();
}
public void b(){
a();
}
}
主动抛出异常
public class Demo02 {
public static void main(String[] args) {
try {
new Demo02().test( 1, 0);
} catch (ArithmeticException e) {
e. printStackTrace();
}
}
//假设这方法中,处理不了这个异常。方法上:抛出异常
public void test(int a,int b) throws ArithmeticException {
if (b == 0) { //throw
throw new ArithmeticException(); //主动的抛出异常,一般在方法中使用
}
System.out.println(a/b);
}
}