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、**转义字符
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EX11hyP4-1655192536159)(D:\java1234\java1234笔记\java1234笔记截图\image-20220508173453575.png)]
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开头，查表
// https://www.cnblogs.com/whiteyun/archive/2010/07/06/1772218.html
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调用构造方法；
如何使用呢，那种情况下可以使用
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hDnkb4mO-1655192536160)(D:\java1234\java1234笔记\java1234笔记截图\image-20220528113446256.png)]
/**
* 定义人类
* @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：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YcnX0MIP-1655192536161)(D:\java1234\java1234笔记\java1234笔记截图\image-20220528113714683.png)]
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
图示：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dUaJkusp-1655192536161)(D:\java1234\java1234笔记\java1234笔记截图\image-20220609164843133.png)]
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
