郑州java培训
郑州文化路中心

400-017-8985

热门课程

郑州java培训:Java入门知识点全在这里了

  • 时间:2018-05-23
  • 发布:郑州达内
  • 来源:郑州java培训网

Java入门知识点全在这里了,想要在郑州java培训班学习技能的学子赶紧行动起来,学习java编程,拿高薪就是这么快!

Java源代码的流程

Java程序由.java文件生成,通过JVM进行编译得到字节文件.class

class HelloWorld {     public static void main(String[] args){         System.out.println("Hello World!");     } }

关于class有如下几点规则:

  1. 文件的名字必须和class的名字一致(public级别的class名字)。

  2. 文件必须只包含一个public访问基本的class(可以包含多个非public级别的class)。

命名规则:

  1. 包(其实就是文件夹,用于解决相同类名问题):包名要求全部小写,一般是公司的域名倒着写 com.heima.包的作用

  2. 类或者接口:如果是一个单词,要求首字母大写,如果是多个单词要求每个单词首字母大写(驼峰命名)

  3. 方法和变量: 如果是一个单词,每个字母都小写,如果是多个单词,从第二个单词开始首字母大写

  4. 常量: 如果是一个单词,所有字母大写,如果是多个单词也是所有字母大写,但是用_分开 MAX MAX_VALUE

Java语言优势:

完全面向对象,安全可靠,跨平台性

(补充)有关于dos命令行方式:

dir md rd cd cd.. cd/ del exit

标识符

由英文字母,数字,_ ,$组成,其中数字不能开头

数据类型(11)

8种原子类型(基本数据类型)

  1. 整数类型:byte(1)、short(2)、int(4)和long(8)。

  2. 小数类型:float(4)和double(8)。

  3. 字符类型:char(2)。

  4. 布尔类型:bool。

3种引用数据类型

interface、class和array

小数类型的常量默认是double类型,声明float类型的常量需要使用F作为后缀。

运算符

  1. 算术运算符:+、-、*、/ 和 %,两个整数相除,结果还是整数。

  2. 赋值运算符:=、+=、-=、*=、/=、%=、&=、|=、~=、^=、<<=、>>= 、 >>>=、++ 和 --。

  3. 比较运算符:==、!=、<、<=、> 和 >=。

  4. 逻辑运算符:&&、|| 和 !。

  5. 位运算符:&、|、~、^、<<、>> 和 >>>。

注意:

  1. 字符串数据和任何数据使用+都是相连接,最终都会变成字符串。//System.out.println(“5+5=”+5+5);//5+5=55

  2. 出现负数取余只看左边。//System.out.println(-1%5);

  3. s+=5;//只一次赋值运算,进行自动转换

  4. &和&&的区别 [&:无论左边是true是false,右边都运算 &&:当左边为false时,右边不运算。同理,|和||的区别一致]

键盘录入

import java.util.Scanner; class Demo_Scanner {     public static void main(String[] args) {         Scanner sc = new Scanner(System.in);         System.out.println("请输入一个整数:");         int x=sc.nextInt();         System.out.println(x);     } }

控制结构

  1. 条件:if-else if-else、switch-case-default和三元运算符(?:)。

  2. 循环:while、do-while、for和foreach。

  3. Labeled block。

注意:

  1. if else结构简写格式:变量=(条件表达式)?表达式1:表达式2;

  2. switch语句中被选择类型的值只有四种:byte short int char;

  3. switch语句里case和default定义位置随机,执行顺序从case开始。

  4. 语句嵌套形式:循环嵌套(大圈套小圈)

//尖朝上,可改变条件,让条件随着外循环变化
//尖朝下,可初始化值,让初始化随着外循环变化

5. break与continue的区别

break:应用范围:选择结构和循环体 跳出所在当前循环
continue:只能用于循环结构 结束本次循环,继续下一次循环

public class Program {     public static void main(String[] args) {         task: {             int age = 25;             System.out.println("start");             if (age < 30) {                 break task;             }             System.out.println("end");         }     } }

字符串

String是拥有“值语义”的引用类型,字符串常量实现了“享元模式”,equals会按照内容进行比较,==按照地址比较。

public class Program {     public static void main(String[] args) {         String x = "小咕噜";         String y = new String("小咕噜");                  System.out.println(x.equals(y)); // true         System.out.println(x == y); // false     } }

为了高效的修改字符串Java引入了StringBuffer

{             StringBuffer sb =                      new StringBuffer()                     .append("小")                     .append("咕")                     .append("噜");                          System.out.println(sb.toString());         }

数组

声明语法

DataType[] name 或 DataType name[]。

public class Program {     public static void main(String[] args) {         {             String[] strs = { "小", "咕", "噜" };             for (String item : strs) {                 System.out.print(item);             }         }     } }

多维数组

只有不等长多维数组DataType[][],没有DataType[xxx, xxx]。

方法

Java中所有的赋值和方法调用都是“按值“处理的,引用类型的值是对象的地址,原始类型的值是其自身。

Java支持变长方法参数。

public class Program {     public static void main(String[] args) {         print("小咕噜", "大咕噜");         print(new String[] { "小咕噜", "大咕噜" });     }     private static void print(String... args) {         for (String item : args) {             System.out.println(item);         }     } }

① 变量在内存中的存储方式:

  1. 成员变量作用于整个类中,存储于堆内存中,因为对象的存在,才在内存中存在,必有初始化值,可参与运算

  2. 局部变量作用于函数中或语句中,存在于栈内存中

②this的应用:

  1. 当定义类中功能时,该函数内部要调用该函数的对象 但凡本类功能内部使用了本类对象,都用this表示。

  2. 用于区分局部变量和成员变量重名的情况代表本类的对象,代表它所在函数所属对象的引用。

  3. 只能定义在构造函数的第一行。

③ 构造代码块: 给所有对象进行统一初始化,优先于构造函数执行

注意:(内存机构:分区)
1.栈内存:用于存储局部变量,当数据使用完,所占空间会自动释放
2.堆内存:①.数组和对象,通过New建立的实例都存放在堆内存中
②.每一个实体都有内存地址值
③.实体中的变量都有默认初始化值
④.实体不再被使用,会在不确定的时间内被垃圾回收器回收
3.方法区,本地方法区,寄存器

public class Program {     public static void main(String[] args) {         Point point = new Point(100);         System.out.print(point);     } } class Point {     private int x = 0;     private int y = 0;     public Point(int x, int y) {         this.x = x;         this.y = y;     }     public Point(int x) {         this(x, x);     }     public String toString() {         return "(x:" + this.x + ",y:" + this.y + ")";     } }

静态成员

Java中类似静态构造方法的结构,称之为:静态初始化代码块,与之对应的是实例初始化代码块,见下例:

public class Program {     public static void main(String[] args) {         System.out.println(Point.getValue());         System.out.println(new Point());     } } class Point {     private static int value = 0;     public static int getValue() {         return value;     }     static {         value++;     }     static {         value++;     }     private int x = 0;     private int y = 0;     {         this.x = 10;     }     {         this.y = 10;     }     public String toString() {         return "(x:" + this.x + ",y:" + this.y + ")";     } }

注意:

  1. 静态方法只能访问静态成员 非静态方法既可以静态也可以访问非静态

  2. 静态方法中不可以定义this,super等关键字 因为静态优先于对象存在

  3. 主函数是静态的

  4. 类变量随着类的加载而存在于方法区中 实例变量随着对象的建立而存在于堆内存中

继承

继承使用 extends,抽象类和抽象方法使用abstract声明,向下转型使用 (ChildType)instance,判断是否是某个类型使用 instanceof,见下例:

public class Program {     public static void main(String[] args) {         printAnimal(new Animal());         printAnimal(new Dog());     }     private static void printAnimal(Animal animal) {         if(animal instanceof Dog){             System.out.println("I am a " + (Dog) animal);         }         else         {             System.out.println("I am an " + animal);         }     } } class Animal {     public String toString() {         return "Animal";     } } class Dog extends Animal {     public String toString() {         return "Dog";     } }

重写

Java中的重写规则比较灵活,具体如下:

  1. 除了 private 修饰之外的所有实例方法都可以重写,不需要显式的声明。

  2. 重写的方法为了显式的表达重写这一概念,使用 @Override进行注解。

  3. 重写的方法可以修改访问修饰符和返回类型,只要和父类的方法兼容(访问级别更高,返回类型更具体)。

  4. 可以使用final将某个方法标记为不可重写。

  5. 在构造方法中使用 super(xxx, xxx)调用父类构造方法,在常规实例方法中使用 super.method(xxx, xxx)调用父类方法。

  6. Java不支持覆盖(new)。

public class Program {     public static void main(String[] args) {         Animal animal = new Animal();         Animal dog = new Dog();         animal.say();         dog.say();         animal.eat(animal);         dog.eat(dog);                  System.out.println(animal.info());         System.out.println(dog.info());     } } class Animal {     private String name = "Animal";     protected void say() {         System.out.println("Animal" + " " + this.name);     }     public void eat(Animal food) {         System.out.println("Animal eat " + food);     }     public Object info() {         return "Animal";     }          @Override     public String toString() {         return "Animal";     } } class Dog extends Animal {     private String name = "Dog";     @Override     public final void say() {         System.out.println("Dog" + " " + this.name);     }     @Override     public final void eat(Animal food) {         super.eat(food);                  System.out.println("Dog eated");     }     @Override     public final String info() {         return "Dog";     }     @Override     public final String toString() {         return "Dog";     } }

Java支持三种导入语法:

  1. 导入类型:import xxx.xxx.xxxClass。

  2. 导入包:import xxx.xxx.xxx.*。

  3. 导入静态成员:import static xxx.xxx.*。

import static util.Helper.*; public class Program {     public static void main(String[] args) {         puts("小咕噜");     } }

访问级别

Java支持四种访问级别:public、private、protected 和 default(默认),类型和接口只能使用public 和 default,成员和嵌套类型可以使用所有,下面简单的解释一下 protected 和 default。

  • protected 修饰过的成员只能被自己、子类和同一个包里的(不包括子包)其他类型访问。

  • default 修改过的类型或成员只能被自己和同一个包里的(不包括子包)其他类型访问。

嵌套类

Java支持如下几种嵌套类:

  1. nested class,定义在类型内部的类型。

    1. static nested class,使用 static 声明的 nested class,static nested class 可以访问所有外部类的静态成员。

    2. inner class,没有使用 static 声明的 nested class,inner class 可以访问所有外部类的实例成员,inner class 不能定义静态成员。

public class Program {     /**      * @param args      */     public static void main(String[] args) {         OuterClass outer = new OuterClass();         OuterClass.InnerClass inner = outer.new InnerClass();         OuterClass.InnerClass.InnerInnerClass innerInner = inner.new InnerInnerClass();         outer.show();         inner.show();         innerInner.show();                  OuterClass.StaticNestedClass staticNested=new OuterClass.StaticNestedClass();         OuterClass.StaticNestedClass.StaticNestedNestedClass staticNestedNested=new OuterClass.StaticNestedClass.StaticNestedNestedClass();                  staticNested.show();         staticNestedNested.show();     } } class OuterClass {     int x = 1;     static int i = 1;     void show() {         System.out.println(x);         System.out.println(i);     }     class InnerClass {         int y = 2;         void show() {             System.out.println(x);             System.out.println(y);         }         class InnerInnerClass {             int z = 3;             void show() {                 System.out.println(OuterClass.this.x);                 System.out.println(y);                 System.out.println(z);             }         }     }     static class StaticNestedClass {         static int j = 2;         void show() {             System.out.println(i);             System.out.println(j);         }         static class StaticNestedNestedClass {             static int k = 3;             void show() {                 System.out.println(i);                 System.out.println(j);                 System.out.println(k);             }         }     } }

特殊的inner class:local class

public class LocalClassExample {     static String staticValue = "static value";     String instanceValue = "instance value";     public void test() {         final String finalLocalValue = "final local value";         class LocalClass {             void test() {                 System.out.println(staticValue);                 System.out.println(instanceValue);                 System.out.println(finalLocalValue);             }         }         LocalClass local = new LocalClass();         local.test();     } }

除了inner class的规则之外,local class可以访问局部final变量,在Java8中有更多的改进。

注意:

1.被final修饰的类不可以被继承,为了避免被继承,被子类复写功能

2.被final修饰的方法不可以被复写

3.被final修饰的变量是一个常量,只能赋值一次i,既可以修饰成员变量,也可以修饰局部变量 作宏定义使用

4.内部类定义在类中的局部位置上时,只能访问该局部被final修饰的局部变量

特殊的local class:anonymous class

public class Program {     /**      * @param args      */     public static void main(String[] args) {         execute(new Action() {             @Override             public void execute() {                 System.out.println("执行业务逻辑");             }         });     }     static void execute(Action action) {         System.out.println("事物开始");         action.execute();         System.out.println("事物结束");     } } interface Action {     void execute(); }

常量

public final class Program {     static final String STATIC_CONSTANTS = "STATIC_CONSTANTS";     final String INSTANCE_CONSTANTS = "INSTANCE_CONSTANTS";     public static void main(String[] args) {         final String LOCAL_CONSTANTS = "LOCAL_CONSTANTS";         System.out.println(STATIC_CONSTANTS);         System.out.println(new Program().INSTANCE_CONSTANTS);         System.out.println(LOCAL_CONSTANTS);         new Program().test("PARAMETER_CONSTANTS");     }     public final void test(final String msg) {         System.out.println(msg);     } }

有一点需要注意的是:只有一种情况Java的常量是编译时常量(编译器会帮你替换),其它情况都是运行时常量,这种情况是:静态类型常量且常量的值可以编译时确定。

接口

Java的接口可以包含方法签名、常量和嵌套类,见下例:

public final class Program {     public static void main(String[] args) {         Playable.EMPTY.play();         new Dog().play();     } } interface Playable {     Playable EMPTY = new EmptyPlayable();     void play();     class EmptyPlayable implements Playable {         @Override         public void play() {             System.out.println("无所事事");         }     } } class Dog implements Playable {     @Override     public void play() {         System.out.println("啃骨头");     }}

异常

Java中的异常分为checked和unchecked,checked异常必须声明在方法中或被捕获,这点我觉得比较好,必定:异常也是API的一部分,见下例:

public final class Program {     public static void main(String[] args) {         try {             test();         } catch (Exception e) {             System.out.println(e.getMessage());         }     }     public static void test() throws Exception {         throw new Exception("I am wrong!");     } }

所有继承Exception的异常(除了RuntimeException和它的后代之外)都是checked异常。

注意:

throws:使用在函数上,后面跟的是异常类,可以跟多个,用逗号隔开
throw:使用在函数内,跟的是异常对象

以上的知识点你掌握了吗,赶紧行动起来吧,郑州java培训老师等你来学习哦!

上一篇:这些都是java大牛总结的java编程实用技巧
下一篇:没有下一篇了
选择城市和中心
贵州省

广西省

海南省