①.java运行机制
文章目录
1. JDK（核心）使用
- 包括Java编译器，Java运行工具，Java文档生成工具，Java打包工具
- JDK包括JRE（JAVA运行工具）
2.JDK目录
- bin目录：存放一些可执行程序 javac.exe（java编译器），java.exe（java运行工具），jar.exe(java打包工具），javadoc.exe(文档生成工具）
- javac.exe：将编写好的java文件编译成java字节码文件 .java->.class
- java.exe：运行字节码文件（.class）
- db目录：小型数据库
- jre目录：java运行时环境，包含java虚拟机，运行时的类包，java应用启动器及一个bin目录
- lib目录：library缩写，是java类库或库文件
3. 环境变量
path：系统环境变量的一种，用于保存一些列路径，，windows从这些路径中查找.exe类型的文件
classpath：classpath也是保存了一系列路径，区别是多了一个class，是jvm从这些路径中查找.class的文件
4.运行机制
- 首先将后缀名为.java的源文件进行编译 使用
javac HelloWord.java命令开启java编译器进行编译生成后缀为 .class的字节码文件 - 使用 java HelloWord 命令启动java虚拟机运行程序，首先将编译的字节码文件加载到内存（类加载，由类加载器玩车），然后虚拟机将内存中的java类进行解释执行，出现结果。
- 由此可见，java程序时由虚拟机负责解释执行的，与操作系统无关，由此实现了跨平台性，但是不同操作系统的虚拟机是不同的。
5.包
- 包是用来专门存放类的
- 编写HelloWord代码，在类之前声明所在的包围“cn.itcast”
package cn.itcast;
class HelloWord{
public static void main(String[] args){
System.out.printf("Hello Word");
}
}
- 使用
javac -d . HelloWord.java命令编译源文件
- -d 指定生成类文件的位置
- . 表示当前目录
- 使用
java cn.itcast.HelloWord运行编译的.class文件
- 由此可见 生成的.class文件都在一个包中，包机制的引入，可以对.class文件进行晋中管理
- import 包名.类名 可以用于不同包之间类的调用
6.常用包
- java.lang：包含java语言的核心类，如String,Math,System和Thread类等，系统会自动导入这个包
- java.util:util工具，包含了大量工具类，集合类等，如Arrays,List,Set
- java.net:包含java网络编程相关的类和接口
- java.io：包含java输入输出相关的类和接口
- java.awt：包含构建图形界面（GUI）相关的类和接口
7.Java应用打包
- JDK中提供了一个jar命令，使用这个命令可以将这些类打包成一个文件，这个文件的扩展名为.jar，全称为Java Archive File(Java档案文件）
- 进入java文件目录，输入命令
jar -cvf helloword.jar cn
- -c 创建归档的文件
- -v 代表标准输出中生成详细输出
- -f 代表指定归档文件名
- 解压后有两个文件
- 运行helloword文件
java -jar helloword.jar
- 这是因为没有指定jar包中的朱磊，也就是找不到程序入口main（）函数在那个类中，图中MANIFEST.MF就是指定jar包中主类的文件
- 拖出这个文件输入代码
- 再次执行
- 解压命令：
jar -续费helloword.jar
②.java基本语法
1.基本格式
- 严格区分大小写
- 标识符由任意大小写字母，下划线（_）,数字，美元$组成，且开头不能是数字
- 包名一律小写
- 类名和接口名一律大写
- 常量名所有字母大写，单词之间用下划线连接
- 变量名和方法名第一个单词首字母小写，第二个单词开始首字母大写
2.强制转换与自动转换
- 需要注意的是：
- 在使用+=，-=，*=，/=，%=运算符进行运算时，强制类型会自动完成，程序不需要任何的显示声明
- 表达式类型的自动提升：如byte b1=3 ;b2=4; byte b3=b1+b2; b1+b2在运算期间自动提升为int类型
3.逻辑运算符
注意：
- &与：无论左边为true或false右边都会进行运算
- &&短路与：当左边为false时，右边不会再进行运算
③.面向对象
3.0 this关键字
- 通过this关键字明确访问一个类的成员变量，解决与局部变量名称冲突的问题
public class Example3 {
int age;
public Example3(int age) {
this.age=age;
}
public int getAge() {
return this.age;
}
}
- 通过this关键字调用成员方法
- 构造方法是实例化对象时被自动调用的，因此不能像调用其他方法一样调用构造方法，但是可以使用“this([参数1，参数2…])的形式来调用其他的构造方法
- 只能再构造方法中使用this调用其他的构造方法，不能再成员方法中使用
- 使用this调用其他构造方法的语句必须再同一行
- 不能再一个类的两个构造方法中使用this互相调用
3.1内部类
package Three_seven;
class Text_1 {
private int num = 4;
//创建方法，调用内部类
public void test() {
Inner in = new Inner();
in.show();
}
//创建内部类，内部类可以在外部类中被使用，并且可以使用外部类成员
class Inner{
void show() {
System.out.println("num="+num);
}
}
}
public class Example16{
public static void main(String[] args) {
Text_1 t1 = new Text_1(); //通过外部类调用内部类
t1.test();
Text_1.Inner out = new Text_1().new Inner(); //直接通过外部类对象去创建内部类对象
out.show();
}
}
- 内部类可以在外部类中被使用，并能访问外部类的成员
- 通过外部类成员访问内部类，需要通过外部类成员去创建内部类对象
外部类名.内部类名 变量名 = new 外部类名().内部类名();
3.2 静态内部类
- 语法：
外部类名.内部类名 变量名 = new 外部类名.内部类名(); - 用static修饰
- 在静态内部类中只能访问外部类的静态成员
- 在静态的内部类中可以定义静态的成员，而在非静态的内部类中不允许定义静态的成员
class Ourter{
private static int num=4;
static class Inner{
void show() {
System.out.println("num:"+num);
}
}
}
public class Example1 {
public static void main(String[] args) {
Ourter.Inner out = new Ourter.Inner();
out.show();
}
}
3.3 方法内部类
- 方法内部类指在成员方法中定义的类，他只能在当前方法中被使用
class Ourters{
private int num=4;
public void test() {
class Inner{
void show() {
System.out.println("num+"+num);
}
}
Inner in = new Inner(); //创建内部类对象
in.show();
}
}
public class Example2 {
public static void main(String[] args) {
Ourters our = new Ourters();//创建外部类对象
our.test();
}
}
3.4继承
- 子类在继承父类时，会自动拥有父类的成员
- 在java中，类只允许单继承，不允许多继承，一个类可以被多个类继承，不允许继承多个类
- 重写父类（重写的方法与被重写的方法要有相同的方法迷宫，参数列表以及返回值类型
class Animal5{
String name;
void shout() {
System.out.println("动物发出叫声");
}
}
class Dog5 extends Animal5{
void shout() {
System.out.println("汪汪。。。。"); //重写父类
}
}
public class Example5 {
public static void main(String[] args) {
Dog5 dog5 = new Dog5();
dog5.shout();
}
}
3.5 super关键字
- （访问父类的成员变量，成员方法和构造方法）
- 格式：
super.成员变量 super.成员方法（[参数1，参数2。。。]）
class Animal7{
public Animal7(String name) { //定义Animal的有参构造方法
System.out.println("我是一只："+name);
}
}
class Dog7 extends Animal7{
public Dog7() {
super("沙皮狗"); //访问父类有参构造方法
}
}
public class Example07 {
public static void main(String[] args) {
Dog7 dog7 = new Dog7();
}
}
如果删除super("沙皮狗");时会报错，原因是：在子类的构造方法中一定会调用父类的某个构造方法，这是可以用super指定，如果未指定，会自动调用父类无参的构造方法
- super调用父类的构造方法
super([参数1，参数2.。。]) - 通过super调用父类的构造方法必须位于子类构造方法的第一行，并且只能出现一次
- 在子类的构造方法中一定会调用父类的某个方法，如果没有指定，在实例化对象时，会自动调用无参的构造方法，为解决这一问题，可以显式的调用父类已有的构造方法，当然也可以在父类中定义无参的构造方法，如下：
class Animal7{
public Animal7() {
System.out.println("我是一只动物");
}
public Animal7(String name) {
System.out.println("我是一只："+name);
}
}
class Dog7 extends Animal7{
public Dog7() {
//无代码
}
}
public class Example07 {
public static void main(String[] args) {
Dog7 dog7 = new Dog7();
}
}
java帮助文档（扩展）
- java中提供的javadoc名利，能够把帮助信息提取出来，自动生成HTML格式的帮助文档，从而实现程序的文档化
javadoc -d . -version -author Person.java
- -d 用来指定输出文档存放的目录
- **.**表示当前目录
- -version用来指定输出文档中包含版本信息
- -author用来指定输出文档中需包含作者信息
package Three_seven;
/*
* Title:Person类<br>
* @author:用于说明该类的作者
* @version:用于说明开发的版本号
* @param（参数）：表示方法定义的参数以及参数对应的说明
* @return：表示参数的返回值
*/
public class Person {
public String name;
/*
* 这是Person类的构造方法
* @param name Person的名字
*/
public Person(String name) {
//执行语句
}
/*
* 这是read（）方法的说明
* @param bookName 读的书的名字
* @param time 读书所需要的时间
* @return 读的书的数量
*/
public int read(String bookName,int time) {
Person per = new Person("as");
int a=2;
return a;
//执行语;
}
}
④.面向对象（下）
1. 继承
- 性质
- 关键字
extends - 子类在继承父类的时候，会自动拥有父类的所有成员
- 类只支持单继承不允许多继承
- 多个类可以继承一个父类
- 一个类的父类可以再去继承另外的父类
- 一个类是父类的同时也可以是一个子类
- 重写父类方法
- 子类会自动继承父类中定义的方法
- 重写的方法要和父类中被重写的方法有相同的方法名，参数列表以及返回值类型
- 子类重写父类方法时，不能使用比父类中被重写的方法更严格的访问权限
2. final关键字
- final关键字修饰的类不能被继承
- 修饰的方法不能被子类重写
- 修饰的变量为常量，只能赋值一次，且修饰的变量为局部变量，需要在定义变量时进行初始化，因为final修饰的变量虚拟机不会对其进行初始化
3. 抽象类
- 关键字
abstract - 包含抽象方法的类必须声明为抽象类，但抽象类可以不包含任何抽象方法，只需要使用abstract关键字修饰
- 抽象类不能被实例化（因为抽象类中可能包含抽象方法，抽象方法没有方法体），可以创建子类来时间抽象类中的抽象方法
4. 接口
- 关键字
interface如果一个抽象类中所有方法都是抽象的，则为接口，实现 ：implements - 接口中方法默认修饰符
public abstract即抽象方法，变量默认是 **public static final**即全局变量 - 由于接口中的方法都是抽象方法，因此不能通过实例化对象来调用接口方法，使用implements来实现接口中的方法
- 可以定义一个接口使用extends去继承另一个接口
interface Animal09{
int ID=1;
void breath();
void run();
}
interface LandAminal extends Animal09{ //接口继承接口
void liveOnLand();
}
class Dog9 implements LandAminal{
public void breath() {
System.out.println("狗在呼吸");
}
public void run() {
System.out.println("狗在游泳");
}
public void liveOnLand() {
System.out.println("狗生活在陆地上");
}
}
public class Example09 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Dog9 dog9 = new Dog9();
dog9.breath();
dog9.run();
dog9.liveOnLand();
}
}
结论：
- 接口中的方法都是抽象的，不能实例化对象
- 当一个类实现接口时，如果这个类是抽象类，则实现接口中的部分方法即可，否则需要实现接口中的所有方法
- 一个类通过implements 关键字实现多个接口，被实现的多个接口用逗号隔开
- 一个接口可以通过extends 关键字继承多个接口，接口之间用逗号隔开
- 一个类在继承另一个类的同时还可以实现接口
5. 多态
- 多态：允许使用一个父类类型的变量来引用一个子类类型的对象，根据被引用子类对象特征的不同，得到不同的运行结果
- 关键字：instanceof（实例） 判断一个对象是都为某个类（或接口）的实例或者子类实例
interface Animal10{
void shout();
}
class Cat10 implements Animal10{
public void shout() {
System.out.println("喵喵...");
}
public void sleep() {
System.out.println("猫在洗澡");
}
}
class Dog10 implements Animal10{
public void shout() {
System.out.println("汪汪...");
}
}
public class Example10 {
public static void main(String[] args) {
//创建子类对象，使用父类对象引用，此时传入的都是animal对象
Animal10 an1 = new Cat10();
Animal10 an2 = new Dog10();
animalShout(an1);
animalShout(an2);
//创建Cat10类的实例对象
Cat10 an3 = new Cat10();
animalShout(an3);
}
public static void animalShout(Animal10 animal) {
animal.shout();
//判断是否为cat类型
if(animal instanceof Cat10) {
Cat10 cat = (Cat10)animal; //Animal10类型可以强转为Cat10类型，而Dog10缺不能强转为cat10
cat.sleep();
}else {
System.out.println("the animal is not a cat");
}
}
}
Animal10 an1 = new Cat10(); Animal10 an2 = new Dog10();将父类引用的两个不同子类对象分别传入，结果输出了不同，可见，多态解决了方法同名的问题，而且更加灵活
6. Object类
- 它是所有类的父类
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
