java自学篇
-----师从----java1234小锋
Java
一、java前篇
1、 了解java的基本信息
2、安装java环境
3、完成一个java实列
// 输出一个hello word
system.out.println("helloword");
二、java语法
1、java的注释:
// 单行注释
/* 多行注释*/ // ctrl+/
/**.文档注释.*/
2、java标识符命名
命名规则:数字、字母、下划线、&符号,java关键字不能作为标识符。不能数字作为开头,[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nUsc7WV5-1655192536158)(D:\java1234\java1234笔记\java1234笔记截图\image-20220508150022678.png)]
3、java基本数据类型
在Java中共有八种基本数据类型,它们分别是以下几种类型:
数据类型 | 描述 | 占用字节 | 取值范围 | 默认值 |
int | 整型,用于存储整数 | 4个字节 | -2147483648~2147483647 | 0 |
byte | Java中最小的数据类型 | 1个字节 | -128~127 | 0 |
short | 短整型 | 2个字节 | -32768~32717 | 0 |
long | 长整型 | 8个字节 | -263~263-1 | 0L |
float | 浮点型,用于存储带小数点的数字 | 4个字节 | / | 0.0f |
double | 双精度浮点型,用于存储带有小数点的数字 | 8个字节 | / | 0.0d |
char | 字符型,用于存储单个字符 | 2个字节 | 0~65535 | 空 |
boolean | 布尔类型,用于判断真或假 | 1个字节 | 仅有两个值,即true、false | false |
//定义一个int变量
int a=1;
System.out.println("a="+a);
//定义一个int类型的变量
int b=2;
System.out.println("b="+b);
// 定义一个byte变量
byte c=1;
System.out.println("c="+c);
// 定义一个short变量
short d=2;
System.out.println("d="+d);
// 定义一个long变量
long e=5;
System.out.println("e="+e);
System.out.println("-----------------------------------------");
int a1=10;
int a2=10;
int a3;
a3=a1+a2;
System.out.println("a1+a2="+a3);
System.out.println("-----------------------------------------");
int a4=1;
int b4=2;
int c4=3;
int d4=4;
int e4=5;
int s;
s=a4+b4+c4+d4+e4;
System.out.println("a4+b4+c4+d4+e4="+s);
//写法2
int x=1+2+3+4+5;
System.out.println("1+2+3+4+5="+x);
// 浮点类型
public static void main(String args[]){
//定义一个float的类型变量
//小数默认是double类型,所以我们必须家一个f,来表示float类型
float f=0.1f;
System.out.println("f="+f);
//定义一个double类型的变量
double d=1.2;
System.out.println("d="+d);
//获取float类型的最大值和最小值并且赋值给maxF和minF;
float maxF=Float.MAX_VALUE;
float minF=Float.MIN_VALUE;
System.out.println("maxF="+maxF);
System.out.println("minF="+minF);
}
**4、**转义字符
package com.java1234;
public class pro04 {
public static void main(String args[]){
//定义一个单字符
char c1='A';
char c2='b';
char c3='3';
System.out.println("c1="+c1);
System.out.println("c2="+c2);
System.out.println("c3="+c3);
// 转义字符,如果需要保存一些特殊的字符,那么需要在特殊符号前加一个反斜杠“ \ ”,否则会被确定为非法字符
char c4='\'';
char c5='\\';
System.out.println(c4+""+c5);
//使用Unicode表输出 \u开头,查表
//
char c6='\u6635';
char c7='\u6685';
char c8='\u6695';
System.out.println(c6+""+c7+""+c8);
// 定义一个布尔类型的变量b
boolean b1=true;
System.out.println("b1="+b1);
// 定义一个布尔类型的变量b2
boolean b2=false;
System.out.println("b2="+b2);
}
}
5、数据类型转换;
5.1基本类型的类型转换分为 :自动类型转换和强制类型转换
public class pro05 {
public static void main(String args[]){
// 自动类型转换
int a=1;
long b;
b=a;
System.out.println(b);
// 强制类型转换
double a1=1.365;
float a2;
// a2=a1; 这种写法,a1的值给a2时候,类型不能自动转换,所以才会如此,
// 数据类型强制转换:在需要转换的数据前加上转换的类型
a2=(float)a1;
System.out.println(a2);
}
}
6、运算符
Java运算符与表达式-自增与自减运算符符号:++(自增); --(自减)
a++是先操作后加1;++a是先加1后操作
public static void main(String[] args) {
int a1=1;
// a1++; 表示先做赋值操作,后自增
int b1=a1++;
System.out.println("b1="+b1);
System.out.println("a1="+a1);
System.out.println("===================");
// ++a2;表示先自增,后做赋值操作
int a2=1;
int b2=++a2;
System.out.println("b2="+b2);
System.out.println("a2="+a2);
}
public class pro07 {
public static void main(String[] args) {
// && 与,前后两个操作数的结果都必须相同,为true,否则返回为false
boolean b1=(5>6)&&(6>7);//false 这个相当于短路了,前面部分为false,无论后面为TRUE为false结果偶读为false
boolean b2=(6>3)&&(7>6);// true
boolean b3=(6>3)&&(7>8);// false
System.out.println("b1="+b1);
System.out.println("b2="+b2);
System.out.println("b3="+b3);
// & 不短路与
boolean a1=(5>6)&(7>8);
System.out.println("a1="+a1);
// || 或,只要一个为true ,返回的结果都为true,一真则真。
boolean a2=(6>5)||(6>7);
System.out.println("a2="+a2);
// | 不短路或 ,前后表达式都会执行,
boolean a3=(4>5)|(6>5);
System.out.println("a3="+a3);
// ! 非,表达式的结果为true,则返回false,否则返回true。
boolean c1=!(5>6);
System.out.println("c1="+c1);
// ^ 异或 ,当两个操作数不相同时返回true,相同的时候返回false
boolean c2=(6>5)^(8>7);
System.out.println("c2="+c2);
// 关系运算符
int a=2;
int b=3;
// >大于
System.out.println(a+">"+b+":"+(a>b));
// <小于
System.out.println(a+"<"+b+":"+(a<b));
// >=大于等于
System.out.println(a+">="+b+":"+(a>=b));
// <=小于等于
System.out.println(a+"<="+b+":"+(a<=b));
// ==等于
System.out.println(a+"=="+b+":"+(a==b));
// !=不等于
System.out.println(a+"!="+b+":"+(a!=b));
// 三目运算符"
String z1=2>3?"表达式是真":"表达式是假";
System.out.println(z1);
boolean z2=(6>5)&&(9>8)?true:false;
System.out.println(z2);
}
}
7、java的选择语句
java中的选择语句用if…else和switch来实现,
package com.java1234;
import java.util.Scanner;
import java.util.*;
public class pro08 {
public static void main(String[] args) {
int a=-2;
// if
if(a>0){
System.out.println(a+":是正数");
}
// if else
if(a>0){
System.out.println(a+":是正数");
}else if(a<0||a!=0){
System.out.println(a+":是负数");
}
// if ...else if ...else
if(a>0){
System.out.println(a+":是正数");
}else if(a<0){
System.out.println(a+":是负数");
}else{
System.out.println("这个数为:"+a);
}
// switch选择语句 不仅仅支持判断int还是支持判断string'类型
// switch语句在使用的时候,每一个case后面写完都必须写一个break的结束语句,在最后的default的
//default相当于if-else的else。efault结构是可选的。位置灵活,可放在末尾,可放在开头,也可放在几个case中间。
//先看case,再看default,看完default再往下走。不想往下走加上break。
//使用官方提供得scanner从控制台获取到一个数据
// Scanner 对象名字(在自己使用时候自己取任意的) =new Scanner(System.in);
System.out.println("请输入一个数字:");
Scanner s =new Scanner(System.in);
int b = s.nextInt();
switch(b){
case 1:{
System.out.println("输入的数为:1");
break;
}
case 2:{
System.out.println("输入的数为:2");
break;
}
default:{
if (b!=1||b!=2){
int x=b;
System.out.println("输入的数为"+x);
}
}
}
}
}
8、循环语句
public class pro10 {
public static void main(String[] args) {
//输出1-10;
//while循环语句 先判断,后执行
int i=1;
int j=1;
while(i<11){
System.out.print(i+" ");
i++;
}
System.out.println("---------------");
/* do....whille语句;
* 先输出在判断*/
do{
System.out.print(j+" ");
j++;
}while(j<16);
//for循环加for循环嵌套
for(int a=0;a<=5;a++){
for(int b=0;b<=5;b++){
System.out.print(" a="+a+" , b="+b);
}
System.out.println();
}
}
}
9、循环语句的控制
break,结束当前循环;
public class Demo17 {
public static void main(String[] args) {
for(int i=0;i<10;i++){
for(int j=0;j<10;j++){
if(i==1){
break;
}
System.out.print("i="+i+" "+"j="+j+" ");
}
System.out.println();
}
}
}
// i=1的这行 没有输出;关键break 还有一个break标签 我们可以从内层跳到//外层,结束外层循环;比如我们只需要输出第一行 我们时候可以用标签实现:
public class Demo17 {
public static void main(String[] args) {
outer:
for(int i=0;i<10;i++){
for(int j=0;j<10;j++){
if(i==1){
break outer;
}
System.out.print("i="+i+" "+"j="+j+" ");
}
System.out.println();
}
}
}
continue语句;
continue是结束当前循环,比如我们输出1到10 但是我们需要把3和6剔除,这时候我们可以用continue来实现:
public class Demo17 {
public static void main(String[] args) {
for(int i=1;i<=10;i++){
if(i==3 || i==6){
continue;//除了第三层和第六层,其他的都能出来,跳出当前循环体
}
System.out.print("i="+i+" ");
}
}
}
return语句;
return语句的话,比较狠,直接结束方法里的内容执行了。
public class Demo17 {
public static void main(String[] args) {
for(int i=0;i<10;i++){
for(int j=0;j<10;j++){
if(i==1){
return;// 只会打印第一层,
}
System.out.print("i="+i+" "+"j="+j+" ");
}
System.out.println();
}
System.out.println("执行到这里");
}
}
10、java数组
数组的定义:type [ ]arrayName(数组名字) 或者 type arrayName(数组名字)[ ]
数组初始化:
1、静态初始化:type 数组名称[ ] =new type[ ]={type1,type2,…};
eg: int arr[ ]=new int[ ]={1,2,3}
1.1当需要查看数组里面全部元素的时候,可以使用
for(int i;i<数组名字.length;i++)
int arr[]=new int[]={1,2,3}
//遍历出数组中的元素
for(int i=1;i<arr.length;i++){
system.out.print(arr[i]); // 数组的下标从0,开始 0,1,2
}
2、动态初始化:type 数组名字[ ]=new type[ length];
eg:int arr[ ] =new int[ 10];
int arr[]=new int[10];
//给数组赋值
arr[0]=10;
arr[3]=20;
3、二维数组:
3.1、二维数组的定义方式:
// java二维数组的静态初始化:
type array[ ][ ]=new type[][]{{},{},{}};,
//实列:
int arr[][]=new int[][]{{1,2},{1,2,3},{4,5,6}}
// java二维数组的动态初始化:
type array[][]=new type[length][length];
//实列:
int arr[][] =new int[5][6];
三、java面向对象
1、面向对象的基本概念;
1.1、java面向对象的三大特性:封装、继承、多态。
封装:我们可以类,类里有方法,属性,可以封装很多功能 仅仅对外暴露一些接口,来实现模块化,组建化,和安全性;
继承:Java中的类可以继承,类似子女可以继承父母的东西;来实现可扩展;
多态:Java中的父类接口可以指向子类实现的引用;
2、类与对象;
2.1、创建一个类:注意事项,在创建类的时候,文件名要与类名相同,否则就会报错,类里面可以写对象的属性,比如一个人有名字,年龄,性别,身高,体重都是特殊的属性,他也有许多的动作行为叫做方法,比如说,说话,睡觉,走路,跑步等等。
2.2、一个类可以有多个对象,
package com.java1234_3;
public class pro15_person {
/*
* */
// 定义一些属性
String name;//姓名
int age;//年龄
String gender;//性别
/*
* 定义一个方法
* 人会说话*
*/
public void speak(){
System.out.println("我是"+name+",我今年"+age+"岁");
}
public static void main(String[] args) {
//定义一个类的对象并且给呀实列化
// 类名 对象名 = 实列化 对象
pro15_person zs=new pro15_person();
zs.name="张三";//给对象的name属性赋值
zs.age=20;// 给对下的age属性赋值
zs.speak();//调用对象的方法
}
}
2.3、在方法中值传递的时候,仅仅改变在方法中的值,在方法里有效,在外部无效,外部使用时,外部的定义变量生效,
//方法里
// 假设这个类名叫cs
void speak(int age){
system.out.print("我今年"+age+"了")
age=24
}
//main函数里
public static viod main(string[] args){
// 初始化一个对象
cs cs1=new cs();
int age=23;
cs1.speak(age);
sysytem.out.println(age);
}
2.4、方法的重载:在方法重载过程中参数类型一样,返回值类型不同,则不算重载。此时会提示方法重名,如:
//在这样的情况下会报错,
long add(int a int b){
return a+b;
}
// 正确示范;
// 方法的重载,参数个数不一样
int add(int a ,int b){
system.out.print("方法一")
return a+b;
}
int add(int a ,int b ,int c){
system.out.print("方法二")
return a+b+c;
}
// 定义了方法,进行对象实列化
public static void main(String[] args){
Demo01 demo=new Demo01();
System.out.println(demo.add(1, 2));
System.out.println(demo.add(1, 2,3));
System.out.println(demo.add(1, "3"));
}
//
// static方法与普通方法
void fun1(){
System.out.println("这是一个普通方法");
}
static void fun2(){
System.out.println("这是一个静态方法");
}
// 调用普通方法 对象.方法
demo.fun1();
// 调用静态方法 类名.方法
pro17.fun2();
demo.fun2();
2.5、递归:
定义:设计一个出口,然后在使用过程中调用自己的方法,
package com.java1234.work;
/*
* F(1)=1, f(2)=1
F(N)=F(N-1)+F(N-2)
*/
public class pro17_work {
static long diGui(int n){
if(n==1 || n==2)
{
return 1;
}
return diGui(n-1)+diGui(n-2);
}
public static void main(String[] args) {
System.out.println(pro17_work.diGui(3));
}
}
2.5、构造方法this关键字
构造方法分为有返回值的方法和没有返回值的方法,无参构造的名字与类名一样,无实际的意义。
实例化对象的时候,String类型的默认值是null,int基本类型的默认值是0 ;
public class pro18 {
private String name;
private int age;
// 含参构造,在实列化对象时候,传入实参,在赋值给属性
// 无参构造,在实列化对象的时候,会自己生成一个空参构造,不起实际的意义。
pro18(String name2,int age2){
System.out.println("这是一个有参数的构造函数");
name=name2;
age=age2;
// pro18(){
// System.out.println("这是一个无参构造函数");
// }
}
public void say(){
System.out.println("我叫"+name+",我今年"+age+"了");
}
public static void main(String[] args) {
pro18 r=new pro18("张珊",20);
r.say();
}
}
this关键字、this表示当前对象
1,使用this调用本类中的属性;
2,使用this调用构造方法;
如何使用呢,那种情况下可以使用
/**
* 定义人类
* @author user
*
*/
public class People {
// 定义属性
private String name; // 实例化对象时,默认值是null
private int age; // 实例化对象时,默认值是0
/**
* 默认构造方法
*/
/*People(){
System.out.println("默认构造方法!");
}*/
/**
* 有参数的构造方法
* @param name
* @param age
*/
People(String name,int age){
System.out.println("调用的是有参数的构造方法");
this.name=name;
this.age=age;
}
public void say(){
System.out.println("我叫:"+name+",我今年:"+age);
}
public static void main(String[] args) {
// People people=new People();
People people=new People("张三",20);
people.say();
}
}
若在构造方法中调用构造方法,使用this关键字也可以实现方法的调用。
eg:
2.6访问控制权限
1.包括主要有 private(私有), package(包访问权限),protected(子类访问权限),public(公共访问权限)
在private定义的属性,在使用时候可以采用get与set接口方法,才能够调用到私有属性,
如:
public class pro19 {
private int a;
// 快捷生成方式 在idea中是ctrl+o,在eclipse中是alt+shift+s
public int getA() {
return a;
}
public void setA(int a) {
this.a = a;
}
}
// ---------------------------------------------------
public class pro19_Test {
public static void main(String[] args) {
pro19 test=new pro19();
//先设置a
test.setA(2);
//在获取a
int a=test.getA();
//在打印输出a
System.out.println(a);
}
}
2.在一个类里面需要加入其他包里的类时候,可以采用import导入
快捷方式:ctrl+shift+o 自动导入包,若 在后面有报错情况,查看导入的类中,是否有不可访问的权限,若有,则修改他的权限为public即可,实时开发过程中,自己小心。
2.7内部类
package com.java1234_3;
public class pro20 {
public int b=10;
// 内部类
class Inner{
public void show(){
System.out.println(b);
}
}
// 外部类
public void show(){
Inner inner=new Inner();
//这里是调用的内部类的show
inner.show();
}
public static void main(String[] args) {
pro20 test=new pro20();
//这里调用的是外部类的show方法
test.show();
}
}
// 以上方法属于间接调用,
// 下面是直接调用
import com.java1234_3.pro20.Inner;
public class pro21 {
public static void main(String[] args) {
// 在调用内部类前,需要将外部类初始化
pro20 test1=new pro20();
// 在使用内部类时候,语法如下
// 外部类名.内部类名 初始化名=外部类初始化名.new 调用的内部类
pro20.Inner test=test1.new Inner();
//这里调用的是是内部类
test.show();
}
}
2.8 代码块
代码块分为普通代码块,写在方法里,
通用代码块,一般写在类里,
静态代码,只执行一次,
2.9、string类
1.实现方式两种
public static void main(String[] args) {
// 实例化String的方式一
String name1="张三";
System.out.println("name1="+name1);
// 实例化String的方式二
String name2=new String("李四");
System.out.println("name2="+name2);
}
2.“==”与“equals方法的区别
// 比较 == 与 equals 的区别
String name1="张三" //直接赋值
String name2=new String("张三"); //通过new的方式赋值
String name3=name2; //传递引用
// ==比较的是引用 判断的结果看地址是否相同
System.out.println("name1==name2:"+(name1==name2)); // False
System.out.println("name1==name3:"+(name1==name3)); // False
System.out.println("name2==name3:"+(name2==name3));// true
// equals比较的是具体内容 判断的结果看值是否相同
System.out.println("name1.equals(name2):"+(name1.equals(name2)));// true
System.out.println("name1.equals(name3:"+(name1.equals(name3)));// true
System.out.println("name2.equals(name3):"+(name2.equals(name3)));// true
图示: