Java入门

最新推荐文章于 2023-03-14 18:42:27 发布

风雪夜不眠人

最新推荐文章于 2023-03-14 18:42:27 发布

阅读量373

点赞数 1

分类专栏： Java

本文链接：https://blog.csdn.net/qq_33519317/article/details/103571745

版权

Java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

1 Java入门

1.一个Java源文件可以定义多个class
2.一个Java源文件中public class不是必须的
3.一个class定义生产一个***.class字节码文件.
4.Java源文件当中public定义的类只能有一个，并且该类名称必须和Java源文件名称一致
5.每一个class中都可以编写main方法，都可以设定程序的入口

1.1、标识符

标识符可以是类名、方法名、变量名、常量名、接口名
一个合法的标识符只能由数字、字母、下划线、美元符号组成，不能含有其他符号
**不能数字开头
**严格区分大小写
**不能是关键字
标识符命名规范
*最好见名知意
*遵守驼峰命名方式
*类名、接口名：首字母大写，后面每个单词首字母大写
*变量名、方法名：首字母小写，后面每个单词首字母大写
*常量名：全部大写

Java使用unicode编码方式，标识符可采用中文

1.2 、数据类型

数据类型	占用空间（字节）
byte	1
short	2
int	4
long	8
float	4
double	8
boolean	1
char	2

数据类型	取值范围
byte	-2⁷~2⁷-1 （-128~127）
short	-2¹⁵~2¹⁵-1
int	-2³¹~2³¹-1
long	-2⁶³~2⁶³-1
float	3.40282347E+38（有效位数6~7位）
double	1.79769313486231570E+308（有效位数15位）
char	0-2³¹-1（0~655535）

char可以存储一个中文字符

1.2.1 整型

以0开头的int值表示八进制
0x开头的int值表示十六进制
自动类型转换：小容量数据可以自动转换为大容量数据。
大容量转换为小容量需要加强制类型转换符，但是会损失精度
Java所有浮点型字面值当做double处理

1.2.2转义字符

System.out.println() //输出内容后换行
System.out.print() //输出内容后不换行
\代表转义，char k=’\’ 表示一个反斜杠

含义	转义符号
回车	‘\r’
换行	‘\n’
Tab	‘\t’
换页	‘\f’
退格	‘\b’

1.2.3 基本数据类型转换规则

1）八种基本数据类型除boolen外均可相互转换
2）小容量向大容量转换，称为自动类型转换，容量从小到大排序

byte < short < int < long < float < double
       char<
       注：任何浮点类型不管占用多少字节，逗比整数型容量大
           char和short可表示的种类数量相同，但是char可以取更大的正整数

3）大容量转换成小容量，叫做强制类型转换，需要加强制类型转换符，程序才能编译通过，但是在运行阶段肯会损失精度，谨慎使用
4）当整数字面值没有超出byte、short、char的取值范围，可以直接赋值给byte、short、char类型的变量
5）byte、short、char混合运算时，各自先转换成int类型再做与少奶奶
6）多种数据类型混合运算，先转换成容量大的类型再做运算

1.3 运算符

1.3.1逻辑运算符

& 逻辑与
&& 短路与
I 逻辑或
|| 短路或
逻辑与和短路与结果相同
逻辑或和短路或结果相同

int x=10；
int y=20;
System.out.println(（x>y）&&(++x>y));
System.out.println((x));

输出结果：false 10
前面的表达式结果为false，后面的表达式则不再计算，这是短路现象

1.3.2 赋值运算符

扩展类的赋值运算符不改变数据类型

byte i = 10;
i=i+10;//编译不能通过,i+10强制转换为int类型
i+=10；//编译可以通过，等同于 i=(byte)(i+10);

1.3.3 字符串的连接运算符

+运算符在Java语言中有两个作用：

加法运算，求和
字符串的连接运算
1）当"+"运算符两边的数据都是数字时，一定进行加法运算
2）当“+”运算符两边的数据主要有一个数据是字符串，一定会进行字符串连接运算，结果为字符串类型。

1.3.4 三元运算符

语法规则：布尔表达式？表达式1：表达式2
如果布尔表达式为true，运行表达式1，布尔表达式为flase，运行表达式2

1.4 控制语句

Java的控制语句7种，3大类
控制选择结构语句：
-if 、 if… else
-switch
控制循环结构语句：
-for
-while
-do while
改变控制语句顺序：
-break
-continue

1.4.1 选择结构

if语句的分支中只有一条语句时，大括号可以省略

从键盘输入添加文件头：
import java.util.Scanner;
代码
Scanner aa=new Scanner(System.in);
aa.next();
//int num=  aa.nextInt();

1.4.2 循环结构

do while

do
{
循环体
}while（boolen判断）

1.4.3改变控制语句

break终止循环，终止最近的循环，跳出循环，不影响外层循环

 for1:for(int i=0;i<5;i++)
        {
          for2:for(int j=0;j<5;j++)
            {
                System.out.print(i);
                System.out.print(' ');
                System.out.println(j);
                break for1;
            }
        }
给for循环命名，可以使用break终止任一层循环

continue终止此次循环，进入下一次循环

1.5 面向对象

面向对象的三大特性：封装、继承、多态
采用面向对象的方式开发一个软件，生命周期当中：

面向对象的分析 OOA
面向对象的设计 OOD
面向对象的编程 OOP

1.6 内存

方法区内存：在类加载的时候，class字节码代码片段被加载到该内存空间当中
栈内存（局部变量）：方法代码片段执行的时候，会给该方法分配内存空间，在栈内存中压栈
堆内存：new的对象在堆内存中存储

new 运算符在堆内存中开辟的内存空间称为对象
引用是一个变量，只不过这个变量保存了另一个java对象的内存地址
java语言中，程序员不能直接操作堆内存，java中没有指针，
java语言中，程序员只能通过“引用”去访问堆内存当中的对象内部的实例变量
JVM内存管理

1、JVM（java虚拟机）主要包括三块内存空间，分别是：栈内存、堆内存、方法区内存
 2、堆内存和方法区内存各有1个。一个线程一个栈内存
 3、方法调用的时候，该方法所需要的的内存在栈内存中分配，成为压栈。方法执行结束之后，该方法所属的内存空间释放，成为弹栈
 4、栈中主要存储的是方法体当中的变量
 5、方法的代码片段以及整个类的代码片段都被存储到方法区内存当中，在类加载的时候这些代码片段会载入
 6、在程序执行过程中使用new运算符创建的java对象，存储在堆内存当中。对象内部有实例变量，所以变量存储在堆内存当中
 7、变量分类：
      -局部变量【方法体中声明】
      -成员变量【方法体外声明】
          *实例变量【前边修饰符没有static】
          *静态变量【前边修饰浮中有static】
  8、静态变量存储在方法区内存当中
  9、三块内存当中变化最频繁的是栈内存，最先有数据的方法的是方法区内存，垃圾回收器主要针对的是堆内存
  10、垃圾回收器【自动垃圾回收机制、GC机制】什么时候会考虑将某个java对象的内存回收呢？
      *当堆内存当中的java对象成为垃圾数据的时候，会被垃圾回收器回收
      *什么时候内存中的java对象会变成垃圾呢？
           没有更多的引用指向它的时候
           这个对象无法访问，因为访问对象只能通过引用的方式访问

1.7封装

1.class中所有对象私有化，使用private修饰,属性只能在此类中使用
2.对外提供简单的操作入口，get和set方法，set修改属性值，get读取属性值
3.setter and getter方法没有static关键字
4.有static关键字修饰的方法调用：类名.方法名（实参）

封装的好处:
1、封装之后，对于那个事物来说，看不到这个事物比较复杂的那-面，只能看到该事物简单的那- -面。
复杂性封装，对外提供简单的操作入口。
2、封装之后才会形成真正的“对象”,真正的独立体”
3、封装就意味着以后的程序可以重复使用。并且这个事物应该适应性比较强，在任何场合都可以使用。
4、封装之后，对于事物本身，提高了安全性。[安全级别高]

1.8 参数传递

Java中参数传递只有一种，值传递，分为两种情况，1有时候传递的为字面值，2有时候传递的为保存的内存地址

int i=10;
int j=i;//i传递给j，实际上是将i变量中保存的10传递给j，i和j属于不同内存空间

class User
{
}
User u=new User;
User u2=u;//u传递给u2，实际上是将u的内存地址传递给u2，u和u2的内存地址不同，但是指向的堆内存中同一个Java对象

参数传递时，传递的是变量保存的值，这个值有字面值和内存地址
参数传递时，普通变量传递的是字面值，实例变量传递的是内存地址。在参数传递过程中，实例对象传递的内存地址，相当于普通变量的字面值

1.9 对象和引用

对象：目前在使用new运算符在堆内存中开辟的内存空间称为对象
引用：是一个变量，不一定是局部变量，还可能是成员变量。引用保存了内存地址，指向了堆内存中的对象
所有访问实例相关的数据，都需要通过引用的方式访问，因为只有通过引用才能找到对象
只有一个空的引用，访问对象的实例相关的数据会出现空指针异常

1.10 this关键字

this不能使用在带有static的方法中
在带有static的方法中不能直接访问实例变量和实例方法
当区分局部变量和实例变量时，this不能省略
1.this可以用在实例方法中，表示当前对象（this.实例方法）
2.可以使用在构造方法中，通过this调用其他构造方法（this（））

this使用在构造方法中，只能在第一行使用
空引用访问实例相关数据，因为实例相关数据就是对象相关的数据，这些在访问的时候，必须有对象的参与，当空引用的时候，对象不存在，访问这些数据一定会出现空指针异常

带有static的方法，其实可以即采用类名的方式访问，也可以采用引用的方式访问，但是即使采用的引用的方式访问，实际上执行的时候和引用指向的对象无关

1.11 static关键字

静态代码块：
1）语法格式

static
{
  java语句;
}

public class test
{
static
   {
      System.out.println("类加载-->1");
   }
   static
   {
      System.out.println("类加载-->2");
   }
   static
   {
      System.out.println("类加载-->3");
   }
}

2）静态代码块在类加载时执行，并且只执行一次
3）静态代码在一个类中科院编写多个，并且遵循自上而下的顺序依次执行
4）静态代码块的作用：在类加载时刻完成日志记录
实例代码块：
1、实例代码块可以编写多个，也是遵循自上而下的顺序依次执行
2、实例代码块在构造方法执行之前执行，构造方法执行依次，实例代码块对应执行一-次。
3、实例代码块也是java语言为程序员准备一个特殊的时机，这个特殊时机被称为:对象初始化时机。

方法定义为静态：
方法描述的是动作,当所有的对象执行这个动作的时候，最终产生影响是-样的, 那么这个动作已经不再属于某一个对象动作了 ,可以将这个动作提升为类级别的动作，模板级别的动作。

静态方法中不能直接访问实例变量和实例方法

1.12 继承

1、继承是面向对象三大特征之一
2、继承的基本作用：代码复用。但是继承最重要的作用是：有了继承才有了方法覆盖和多态机制
3、继承语法格式：
[修饰符列表] class 类名 extends 父类名
{

}
4、java语言中继承只支持单继承，一个类不能同时继承很多类，只能继承一个类。在C++中支持多继承
5、术语
B类继承A类
A类称为：父类、基类、超类、superclass
B类称为：子类、派生类、subclass
6、java语言中子类继承父类可以继承的数据：
–私有的不支持继承
–构造方法不支持继承
–其他数据都可以被继承
7、虽然java语言中只支持单继承，但是一个类可以间接继承其他类，如：
C extends B
{
}
B extends A{
}
A extends T {
}
C直接继承B类，但是C间接继承A类和T类
8、java语言中假设一一个类没有显示的继承任何类，该类默认继承JavaSE库当中提供的java.lang .object类。
java语言中任何一个类都有Object类的特征

1.13 覆盖

1、方法覆盖又称为方法重写

2、当父类中的方法已经无法满足当前子类的业务需求,子类有必要将父类中继承过来的方法进行重新编写，这个重新编写的过程称为方法重写/方法覆盖。|
3、

方法重写发生在具有继承关系的父子类之间
返回值类型相同，方法名相同，形参列表相同
访问权限不能更低，可以更高。
抛出异常不能更多，可以更少。

4、注意：

私有方法不能继承，所以不能覆盖。
构造方法不能继承，所以不能覆盖。
静态方法不存在覆盖。
覆盖只针对方法，不谈属性

1.14 多态

1、多态中的概念：

向上转型（upcasting）
向下转型（downcasting）
基本类型转换，子类型向父类型转换是向上转型（自动类型转换），父类型转换为子类型，是向下转型（强制类型转换）
无论是向上转型还是向下转型，两种类型之间必须要有继承关系。

public class A
{
   public void C(){
   }
    public void D(){
   }
}
public class B extends A
{
   public void C(){
   }
     public void E(){
   } 
}
public class BB extends A
{
   
}
//向上转型
//java中允许这种语法，父类型引用指向子类型对象
//A与B必须有继承关系，否则会报错
A a=new B();
a.C();

编译阶段，a使用的方法只能是A类的方法，不能使用B中的方法（静态绑定，编译阶段绑定）
运行阶段，运行的是B类的方法，（动态绑定，运行阶段绑定）
a无法调用B类中的方法E，可以将a的类型强制转换为B类型，向下转型
向下转型必须需要两种类型有继承关系，强制转换需要加强制类型转换符
当调用的方法是子类型中特有的，在父类中不存在，必须进行向下转型

//向下转型
b a2=(B)a;

A aa=new B();
BB aa2=(BB) aa;
//上述代码由于A类和BB类存在继承关系，编译阶段程序不会报错，但是在运行阶段，会出现异常
java.lang.ClassCastException:
//类型转换异常，这种异常总是在向下转型是发生

向上转型只要编译通过，运行一定不会出错
向下转型编译通过，运行可能出错
instanceof运算符可以避免出现ClassCastException错误

instanceof语法格式：（引用 instanceof 数据类型名）
结果：布尔类型，true表示引用指向的对象是这个数据类型，false表示引用指向的对象不是这个数据类型

多态的作用是什么：

面向抽象编程，不要面向具体编程。降低程序的耦合度，提高程序的扩展力。
能使用多态尽量使用多态。
父类型引用指向子类型对象。

1.15 final关键字

final修饰的类无法被继承
final修饰的方法无法被覆盖
final修饰的变量赋值后，不可重新赋值
final修饰的实例变量必须手动赋值，否则将采用系统默认值，无法再次赋值
final修饰的引用指向一个对象后，不能在修改指向其他对象，但指向对象内部的内存可以修改
final修饰的实例变量是不可变的，这种变量一般与static联合使用，被称为常量
public static final 修饰的是常量

1.14 super关键字

如果类没有构造方法，系统会默认一个无参数构造方法，如果有一个有参构造方法，则系统不再提供无参数构造方法
语法：super.和super()
super（）只能出现在构造方法第一行，通过当前的构造方法区调用父类中的构造方法，目的是：创建子类对象时候，先初始化父类特征
当一个构造方法第一行既没有this()有没有super()的话，默认会有一个super（）；表示通过当前子类的构造方法调用父类的无参数构造方法，必须保证父类的无参数构造方法是存在的。
this与super不能共存
如果第一行没有super（）构造方法，系统会默认有一行super（）；
父类的构造方法一定会执行

1.15 接口

接口也是一种引用数据类型。编译之后生成class字节码文件
接口是完全抽象的（抽象类是半抽象的）

//接口定义
[修饰符列表] interface 接口名{}

接口中只包含两部分内容，一是常量，二是抽象方法，接口中没有其他内容
一个接口可以继承多个接口（支持多继承）

interface A{}
interface B{}
interface C exyends A,B{
int sum（int a,int b）;
}

接口中所有元素都是public修饰
定义时方法的public abstract 可以省略
常量的public static final 也可以省略
接口中的抽象方法都是抽象方法，不能有方法体
接口是特殊的抽象类，完全抽象

风雪夜不眠人

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java入门

1.一个Java源文件可以定义多个class2.一个Java源文件中public class不是必须的3.一个class定义生产一个***.class字节码文件.4.Java源文件当中public定义的类只能有一个，并且该类名称必须和Java源文件名称一致5.每一个class中都可以编写main方法，都可以设定程序的入口...
复制链接

扫一扫

专栏目录