Java教程

Java拓展

本文主要是介绍Java拓展,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

文章目录

  • Java拓展
    • 预科
    • 入门
    • 基础
    • 流程控制
    • 方法Method
    • 数组
    • 面向对象
    • 异常
    • 常用类

Java拓展

预科

  • The name TIOBE stands for “The Importance Of Being Earnest”

  • blink眨眼睛

  • 结束资源管理器,无桌面,再次运行运行新任务,输入explorer

  • 托拉斯trust,反托拉斯=反垄断

  • 高级语言分为面向对象和面向过程

  • C语言固然接近底层,但是指针和内存管理不利于小白,易报错

入门

  • Java本来是C++ - -

  • Java在计算机上安装JVM即可运行Java

  • Java分三种JavaSE、JavaME、JavaEE( exploit)

  • JDK(develpment kit) JRE(runtime environment) JVM

  • API(application program interface)

  • .jar (java archive) .lib(library):一种是静态库存实现代码,一种是配合.dll使用,里面没有代码,代码在.dll中,lib起链接作用,链接完成.lib就没有作用了 。 如果是动态.dll根本用不到.lib

  • cmd中输入 java -version。会出现Java版本信息

  • 配置环境变量JAVA_HOME,还有path中的jdk\bin和jdk\jre\bin。或者%JAVA_Home%\bin

  • jdk中的bin存可执行文件例如java.exe和javac.exe。

  • include包含c语言的头文件。

  • lib存放的是jar包库文件

  • src.zip是存放Java的核心代码

public class Hello{
	public static void main(String[] args){//args是arguments的缩写
		System.out.print("hello ,world");//类  对象    方法
	}
}
#cmd 路径
javac Hello.java   #生成Hello.class			
java Hello		  #输出hello world		//自动找寻.class文件
  • java对于大小写敏感
  • 文件名和类名要一致,首字母驼峰原则大写
  • 编译型:例如操作系统,C语言
  • 解释型:例如网页
  • Java既有编译,又有解释
  • Hello.java经过java编译器成Hello.class。进入类装载器,通过字节校验码(判断代码是否出错),然后利用解释器到操作系统平台
  • IDE(integrated development environment)集成开发环境,有编辑器,编译器,调试器 ,用户图形界面
  • template模版 groovy绝妙的 demo(demostrate) apply应用 annotation注解 comment注释
  • Italy意大利 italic斜体

基础

  • 创建一个Hello项目之后,在src文件夹中创建一个Hello.java。

  • 输入psvm(public static void main(String [] args)),连大括号都创建好

  • 输入sout,创建System.out.println();

  • 要有注释

    • 单行注释//
    • 多行注释/* 此处是好几行 */(输入/**回车即可生成javadoc)
  • 类名、变量名、方法名都称为标识符。不可与关键字重复

  • 标识符大小写敏感

  • 可以用汉字命名,太low。坚决不用

  • 强类型语言,严格符合规定。Java即先定义再使用

  • 弱类型语言,例如js

  • Java数据类型分为primitive type和 reference type

    • 基本类型byte,short,int,long,
    • float,double,BigDecimal
    • boolean,char
    • 引用类型。类(String),数组,接口
  • ascii 1。UCS-2 UCS-4 。utf-8 1~4字节。

  • type varNmae = value

  • Integer,然后按住ctrl,点击字符,即可查看具体内容

  • 二进制0b10;八进制010;十进制10;十六进制0x10;

  • 在运行demo3.java时,其他的文件也不能出错,否则报错

  • 通过(int)强制转换,所有的字符本质还是数字。unicode,a=97,A=65**。但是在unicode中是十六进制,即c1=’\u0061’为a**,理解表象。

  • \t为tab。\n为换行

  • if(flag)大佬-------------//Less is more

  • 强制转换( 从高到低)。自动转换(从低到高)

    • 不可进行布尔转换
    • 不可转换为不相干的类型
  • System.out.println((int)12.4);   //12
    System.out.println((int)-13.4);		//-13
    
    System.out.println("======================");
    
    char c1 = 'a';
    int a = c1+1;
    System.out.println(a);			//98
    System.out.println((char)a);    //输出b 
    
  • int money = 10_0000_0000;			//无视_,对于位数较多的数字,采取这种方式a = 10_0_0也可以
    int years=20;
    System.out.println(money);          
    
    long total1 = years*money;
    long total2 = (long)money*years;
    
    System.out.println(total1);   //输出错误,越界,为负数
    System.out.println(total2);     //输出正确
    
  • 类里面有方法,例如class中有main

  • 变量作用域

    • 类变量:static
    • 实例变量:无static
    • 局部变量:例如在main方法里面定义i,只能在main里面用
  • 除了基本类型为0,其余全为null

  • public class Demo5 {
        static double salary=2500;           //类变量
        static final double salary2 = 3000; //类常量,不可更改
    
        String name;            //实例变量
        int age;           //实例变量
        
        public static void main(String[] args) {
            Demo5 a = new Demo5();
            System.out.println(a.age);          //输出0
            System.out.println(a.name);         //输出null
            System.out.println(salary);
        }
    }
    
    
  • 变量命名规则

    • 所有变量:见名知意
    • 变量和方法名:lastName首字母小写驼峰原则
    • 常量MAX_VALUE
    • 类名:LastName(首字母大写和驼峰原则)
  • instanceof运算符

    • 算数运算符:加减乘除,商余,++,- -
    • 赋值运算符
    • 关系运算符
    • 逻辑运算符,与或非
    • 位运算符& | ^ ~ << >>
    • 条件运算符? :
    • 扩展赋值运算符
  • 快捷键,ctrl+d。cast转换。abs(absolute)绝对值

  • double pow = Math.pow(2,3);
    System.out.println(pow);
    
    boolean a =true;
    boolean b = false;
    System.out.println("a && b: "+(a&&b));
    
    char a = 5;
    System.out.println(a++<6);  //先比较,再自增
    
    int a=10;
    int b=20;
    System.out.println(""+a+b);         //1020
    System.out.println(a+b+"");         //30
    
  • 包机制。一般将公司域名倒置,作为包名。例如www.baidu.com。baike.baidu.com。直接倒置com.baidu.www

  • Date。直接输入会报错,输入Date后进行alt加enter,直接进行选择导入包即可

  • JavaDoc命令是用来生成自己的api文档

    • @auther
    • @version
    • @since 最早需要使用jdk的版本
    • @param
    • @return
    • @throws
  • public class Test {
        String name;
    
        /**                            //输入/**回车即可自动生成
         * 
         * @param name
         * @return
         * @throws Exception
         */
    
        public String test(String name) throws Exception{
            return name;
        }
    }
    
  • 加在类的上面就是类的注解。加在方法的上面就是方法的注解

public class Hello{

/**
*@author adair
*@parm args
*@throws null
*@since 1.0
*/
public static void main(String[] args){
	
	for(int i=0; i < args.length ; i++){
		System.out.println(args[i]);
	}
}
}


cmd
javac Hello.java
java Hello zhang qing lin

流程控制

  • Scanner scanner = new Scanner(System.in);//直接输入new Scanner(System.in)然后alt+enter
    if(scanner.hasNextLine()){
        String str = scanner.nextLine();
        System.out.println(str);
    }
    //凡是属于IO流的类,如果不关闭会一直占用资源
    scanner.close();   //小写的scanner
    
  • hasnext表示有空格后面的就不要了。hasnextline以回车为结束符,可以接受空格

Scanner scanner = new Scanner(System.in);

double sum=0;
int m=0;
while(scanner.hasNextDouble()){
    double  x = scanner.nextDouble();
    sum+=x;
    m++;
    System.out.println("你输入了"+m+"个数据,然后当前结果为"+sum);
}
System.out.println(m+"个数据当前的总数sum:"+sum);
System.out.println(m+"个数据当前的平均数average:"+sum/m);
scanner.close();
int i=0;
float f=0.0f;
Scanner scanner = new Scanner(System.in);
System.out.println("请输入整数:");
if(scanner.hasNextInt()){
	i = scanner.nextInt();
	System.out.println("整数部分:"+i);
}else {
	System.out.println("输入不是整数");
}

System.out.println("请输入小数:");
if(scanner.hasNextFloat()){
	f = scanner.nextFloat();
	System.out.println("小数部分:"+f);
}else {
	System.out.println("输入不是小数");
}
scanner.close();
char grade = 'C';		//还可以是字符串
switch (grade){
    case 'A':
        System.out.println("优秀");
        break;
    case 'B':
        System.out.println("良好");
        break;
    case 'C':
        System.out.println("还好");
        break;
    case 'D':
        System.out.println("一般");
        break;
    case 'E':
        System.out.println("不及格");
        break;
    default:
        System.out.println("不知道");
}
  • 反编译:在项目结构(project structure)的Project选项中,找到编译输出的文件路径,可以直接把文件拖进项目文件夹中,进行查看,可以知道在switch中使用哈希值进行的判断。一个优秀的程序员必备的思想

  • int[] numbers = {10,20,30,40,50};
    for(int x:numbers){
        System.out.println(x);
    }
    
  • break和continue

  • 对于for循环嵌套,可以先确定ij的根据结果估计大小和数量,在进行确定i和j的精度

  • 程序设计语言

  • Label 标签 : continue outer

  • 快捷方式

    • 10.for
    • fori回车
  • for (int i = 1; i <= 5; i++) {
        for(int j=5;j > i;j--){
            System.out.print(" ");
        }
        for(int j = 1;j <=i ; j++){
            System.out.print("*");
        }
        for(int j = 1;j < i ; j++){
            System.out.print("*");
        }
        System.out.println();
    }
    

方法Method

System.out.println();
  • system为类(和Demo差不多),out对象,println方法(类似与C语言中的函数)。但是在一般情况下只有类和方法。而且泛泛的说,类是代码,对象是实际的数据

  • //main方法
    public static void main(String[] args) {
        int sum = add(3,4);
        System.out.println(sum);
    }
    public static int add(int a,int b){		//修饰符 返回类型 方法名
        return a+b;
    }
    
  • 设计方法的原则,原子性:一个方法只完成一个功能

  • main里面尽量保持整洁,方法建立在main函数之外

  • 方法的重载

    • 名称必须一样
    • 参数列表不能一样
    • 返回值无所谓
  • 命令行传参

  • public static void main(String[] args) {
            for (int i = 0; i < args.length; i++) {
                System.out.println("内容 "+args[i]);
            }
    }
    
    C:\Users\Adair\Desktop\JavaSE\基础语法\src\com\adair\method>cd ..
    
    C:\Users\Adair\Desktop\JavaSE\基础语法\src\com\adair>cd ..
    
    C:\Users\Adair\Desktop\JavaSE\基础语法\src\com>cd ..
    
    C:\Users\Adair\Desktop\JavaSE\基础语法\src>java com.adair.method.Demo03 this is adair
    agrs[ 0]this
    agrs[ 1]is
    agrs[ 2]adair
    
  • 可变参数,固定参数必须要放到可变参数之前

  • public static void main(String[] args) {
        Demo04 demo04 = new Demo04();
        demo04.test(1,2,3,4,5);
    
    }
    public void test(int...i){			//i相当于一个数组名
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
        System.out.println(i[4]);
    }
    
  • 递归。递归头(什么时候结束),递归体(什么时候调用自己)

  • public static void main(String[] args) {
        System.out.println(f(10));
    }
    public static int f(int a){     //f(5)调用f(4)相当于f(5)在栈底,栈顶为f(1)
        if(a==1){
            return 1;
        }else{
            return a*f(a-1);
        }
    
    }
    
  • 根据递归的基本理论可知,只可以用一些小方法,不可用于大工程。

数组

  • 声明数组和创建数组
int[] nums;             //首选 动态初始化(包含默认初始化)         声明数组  to   栈
nums = new int[4]		//创建数组  			to 堆
int nums2[];            //为了以前的程序员C/C++
  • 创建数组,数组的大小在创建时就被确定了,不可以在进行更改

  • int[] nums = new int[4];			//声明+创建
    
  • int[] a={1,2,3,4};      //静态初始化,创建+赋值
    
  • 数组本身就是引用变量,数组也是对象,数组中的成员可以是引用变量

  • int[] arrays = {1,2,3,4};
    for (int array : arrays) {      //增强型for,arrays.for直接回车快捷键
        System.out.println(array);
    
    }
    
  • int[][] a = new int[4][2];
    
  • util等于utility利用,crlf:carriage return linefeed回车换行。

  • 数组本身并没有什么方法让我们去调用,但API提供了工具类Arrays,直接调用对数据对象进行基本操作,在jdk api中 查看方法

  • Arrays中的类都是使用static修饰的静态方法,可以直接进行调用,不用使用对象来调用。

  • int[] arrays = {23,345,76,83,9056};
    System.out.println(arrays);         //输出[I@4554617c
    System.out.println(Arrays.toString(arrays));        //[23, 345, 76, 83, 9056]
    Arrays.sort(arrays);		//Arrays是一个工具类
    System.out.println(Arrays.toString(arrays));        //[23, 76, 83, 345, 9056]
    Arrays.fill(arrays,3,5,,2);			//把arrays全部[3,5)填充为2
    
  • Arrays.fill(arrays,2,4,2);			//把[a[2],a[4])
    System.out.println(Arrays.toString(arrays));        //[23, 76, 2, 2, 9056]
    
  • 八大排序:冒泡、选择、插入、快速、归并、希尔、堆、基数

  • array1.for。然后回车强化性for 循环

  • package com.adair.array;
    
    public class ArrayDemo08 {
        public static void main(String[] args) {
            int[][] array1 = new int[11][11];
            array1[1][2] = 1;
            array1[2][3] = 2;
            System.out.println("输出原始:");
            for (int[] ints : array1) {
                for (int anInt : ints) {
                    System.out.print(anInt+"\t");
                }
                System.out.println();
                
            }
            System.out.println("===================");
            
            //获取有效数字
            int nums = 0;
            for (int i = 0; i < 11; i++) {
                for (int j = 0; j < 11; j++) {
                    if(array1[i][j]!=0){
                        nums++;
                    }
                }
            }
            System.out.println("有效值的个数:"+nums);
            int[][] array2 = new int[nums+1][3];
            array2[0][0] = 11;
            array2[0][1] = 11;
            array2[0][2] = nums;
            int count = 0;
            for (int i = 0; i < array1.length; i++) {
                for (int j = 0; j < array1[i].length; j++) {
                    if(array1[i][j]!=0){
                        count++;
                        array2[count][0] = i;
                        array2[count][1] = j;
                        array2[count][2] = array1[i][j];
    
                    }
                }
            }
            System.out.println("输入稀疏矩阵:");
            for (int i = 0; i < array2.length; i++) {
                System.out.println(array2[i][0]+"\t"
                +array2[i][1]+"\t"+array2[i][2]);
            }
            System.out.println("================");
            System.out.println("还原数组");
            //还原数组
            int[][] array3 = new int[array2[0][0]][array2[0][1]];
            for (int i = 1; i < array2.length; i++) {
                array3[array2[i][0]][array2[i][1]] = array2[i][2];
    
            }
            for (int[] ints : array1) {
                for (int anInt : ints) {
                    System.out.print(anInt+"\t");
                }
                System.out.println();
    
            }
        }
    }
    
    

面向对象

  • OOP面向对象编程object oriented programming。OO指的是面向对象

  • 面向过程编程(procedure oriented Programming)(POP)。面向过程是第一步做什么,第二步做什么,适合与简单的问题。

  • 函数式编程(functional programming)(FP)

  • 面向对象 ,物以类聚,分类的思想, 解决问题需要哪些类,对这些类在进行单独思考。最后,在这些分类细节进行过程的思考,适合处理复杂的问题。在宏观上进行面向对象,在微观上进行面向过程。

  • 面向对象的本质:以类的方式组织代码,以对象的形式封装数据。类是代码,对象是实在的数据

  • 构造方法的重载,如果定义了有参构造,则必须定义无参构造

  • new对象:栈存放引用,堆存放具体的对象

  • 三大特性:封装,继承,多态

    • 封装:私有属性,set/get
    • 继承 :extends,Object,子类拥有父类的全部特性 ,方法重写,this,super
    • 多态:父类的引用指向子类对象,可以用stanceof,进行类型之间的转换
  • 修饰符public,protected,default, private,static,abstract,final

  • 接口interface:约束,只可定义方法名,子类实现接口必须重写其中的方法,只有一个接口的方法叫做函数式接口,可以使用lambda表达式简化,接口比抽象类更抽象,可以多接口,(继承:单继承)

  • 内部类:成员内部类,静态内部类,匿名内部类,局部内部类

  • 静态方法,直接进行调用

  • package com.oop.demo01;
    
    public class Demo02 {				//类
        public static void main(String[] args) {		//方法
            Student.say();				//虽然在其他的类中,由于方法是静态的,故不用new
        }
    }
    
    package com.oop.demo01;
    
    public class Student {					//类
        public static void say(){			//方法
            System.out.println("学生说话了");
        }
    }
    
  • 非静态方法

package com.oop.demo01;
public class Demo02 {
    public static void main(String[] args) {
        Student student = new Student();			//实例化,这个类
        student.say();
    }
}

package com.oop.demo01;
public class Student {				//没有static,非静态,需要在main中进行new
    public void say(){
        System.out.println("学生说话了");
    }
}
  public  static void a(){
     // b()不可以被a()用,因为b()现在还不存在,需要进行new;
  }
  public void b(){
      a();
  }
  • 值传递和引用传递。引用传递:对象,本质还是值传递

  • //这是从Demo04粘过来的
    public static void main(String[] args) {		//值传递
        int a = 1;
        Demo04.change(a);
        System.out.println(a);  //1
    }
    
    public static void change(int a){
        a = 10;
    }
    
public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);
        change(person);
        System.out.println(person.name);

    }
    public static void change(Person person){		//引用传递
        person.name = "adair";
    }


}
class Person{				//直接定义的类,没有定义方法,又一个变量name
    String name;
}
  • 从认识论的角度,先有对象后有类。对象是具体的事物,类是对对象的抽象

  • 从运行角度来说,先有类后对象。

  • 一个项目只存在一个main方法

  • 类与对象的创建

  • package com.oop.demo02;  //这是package,下面有多个.java文件
    //类是抽象的,需要去实体化
    public class Student {
        String name;
        int age;
        public void study(){
            System.out.println(this.name+"学生在学习");
        }
    }
    
    package com.oop.demo02;		 //这是package,下面有多个.java文件
    public class Application {
        public static void main(String[] args) {
            Student student1 = new Student();
            Student xiaohong = new Student();
            student1.name = "xiaoming";
            student1.age = 3;
    
            System.out.println(student1.name);  //xiaoming
            System.out.println(student1.age);   //3
    
        }
    }
    
  • 构造器也称为构造方法。必须和类的名字一样,没有返回类型,也不可以写void。public Person(){} //且类名是Person

  • 一个类即使什么都不写,也会存在一个方法

  • //
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    package com.oop.demo02;		//由java生成的class文件
    
    public class Person {
        public Person() {			//会自动生成最少一个方法
        }
    }
    
    
  • package com.oop.demo02;
    public class Person {
       String name;
       int age;
        //使用new本身是在使用构造器,初始化值
      	public Person(String name, int age) {		//alt+insert然后constructor,直接生成构造器
            this.name = name;					//public Person()非常重要,
            this.age = age;
        }
            
        }
        //一旦定义了有参构造,无参构造必须显式定义。此处利用了重载
    
    
  • 一般来说,构造一个无参构造器,空着什么都不写。然后利用有参构造进行处理

  • alt+insert为构造生成器,constructor,然后选择所要的参数

  • 关于内存:栈是用来存方法序列的,main在栈底。方法区是用来存类和static静态方法区,在执行的时候静态虽方法一起进行加载。堆是用来存具体的内容

  • 类名之后没有()。而方法名之后有()。类public class Student{} 。

  • 如果demo03文件夹和Application.java并排,demo03下有Pet.java,则Pet中的变量需要public修饰

  • 类是一个模版,而对象是一个具体的实例

  • 对应的引用

    • 基本类型
    • 引用类型:例如在栈和堆地址,进行操作
  • 类中只有属性和方法

    • 默认初始化为0 ,字符串为null
  • 修饰符 属性类型 属性名 = 属性值

  • 对象的创建和使用

    • 必须使用new。
    • 构造器。
  • 类:静态的属性,动态的方法。

  • 程序的封装:高内聚,低耦合 。。一句话,私有属性set/get

  • .package com.oop;
    
    import com.oop.demo04.Student;
    
    public class Application {
        public static void main(String[] args) {
            Student s1 = new Student();
            s1.setName("zhangsan");
            System.out.println(s1.getName());
            s1.setAge(-1);
            System.out.println(s1.getAge());
        }
    }
       package com.oop.demo04;
    
      //隐藏代码,提供统一接口
    
      //提高安全性
    
      public class Student {
      
    
        //s1是不可以直接调用的,如果修饰符public可以直接调用
        private String name;
        private int age;
        
        //故我们要提供get 、set之类的方法
        public String getName(){
            return this.name;
        }
        public void setName(String name){
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        
        public void setAge(int age) {     
                this.age = age;
            }
        }
        
    
       }
    
    

=================================================

  • 程序的继承,还有依赖、组合、聚合。extends“扩展”,子类是父类的扩展

      package com.oop.demo05;
      
      public class Person {
        //如果public变成private,Student就不可以用了
        public int money =10_0;
        public void say(){
            System.out.println("hello world");
          }
      }
      
      
      package com.oop;
      import com.oop.demo05.Student;
      public class Application {
          public static void main(String[] args) {
              Student s1 = new Student();
              s1.say();
              System.out.println(s1.money);
          }    
      
      }
      
    
    
  • Java中只有单继承,没有多继承。一个儿子只有一个爸爸,一个爸爸可以有多个儿子,儿子间接继承爷爷的,且私有private不可以继承

    package com.oop;
    import com.oop.demo05.Student;
    public class Application {
    public static void main(String[] args) {
    Student s1 = new Student();//输出:Person无参执行 Student无参执行
    s1.test(“adair”);//adair qinjiang kuangshen
    s1.test1();//Student Student Person
    }
    }

    package com.oop.demo05;
    public class Student extends Person{
    public Student() { //构造器
    //此处有隐藏代码super(),因为输出"Person无参执行"
    super();//可省略,写的话一定要在第一行
    //this(有参的话,传递参数)。也可以调用本身的有或无参构造器,但是父子只可以用一个
    System.out.println(“Student无参执行”);
    }
    private String name = “qinjiang”;
    public void test(String name){
    System.out.println(name);
    System.out.println(this.name);
    System.out.println(super.name);
    }
    public void print(){
    System.out.println(“Student”);
    }
    public void test1(){
    print();
    this.print();
    super.print();
    }
    }

    package com.oop.demo05;
    //在java中所有的类,都直接或间接继承object类
    public class Person /extends Object/{
    public Person() {
    System.out.println(“Person无参执行”);
    }
    protected String name = “kuangshen”;
    public void print(){
    System.out.println(“Person”);
    }
    }

     
  • super注意点

    • super调用父类的构造方法,必须在构造方法的第一个
    • super和this不可同时出现调用构造方法
  • this

    • this本身调用者
    • 没有继承也可以使用,super只可以在继承条件下可以使用
  • 重写:在父子Override: ( 重载:是在一个方法中)

    • 方法名字一样,方法体不一样
    • 参数一样
    • 修饰符:范围可以大,不可以小public >protected>default>private
    • 抛出的异常,范围可以小,不可大。ClassNotFoundException <Exception(大)

=======================================

  package com.oop;

  import com.oop.demo05.A;

  import com.oop.demo05.B;

  public class Application {

public static void main(String[] args) {
      //方法的调用只和左边的,定义数据类型有关
      A a = new A();
      a.test();       //B->test

      //父类的引用指向子类
      B b  = new A();
      b.test();       //动态A->test
  }
    }

  package com.oop.demo05;

  public class A extends B{
  

      @Override//重写,非静态才可以重写
      public void test() {//又没有static关系重大
          super.test();
      }
    

  }

  package com.oop.demo05;

  public class B {
  public void test(){//又没有static关系重大
      System.out.println("B->test");
  }
  }

================

- 如果B b = new A()//B是A的爸爸;且A和B中都有public void test()方法,则调用儿子A中的test

- 多态

  - 多态是方法的多态,属性没有多态
  - 父子类转换异常。ClassCastException
  - 存在条件:继承,方法重写,父类引用指向子类  **Father f1 = new Son();不可以反过来**

- 不存在多态

  - static方法,不属于实例,不可以用new的对象引用
  - final 常量,
  - private

===================

package com.oop;

import com.oop.demo06.Person;

import com.oop.demo06.Student;

public class Application {

public static void main(String[] args) {
    //调用子类和父类,
    Student s1 = new Student();
    //调用父类,不可用子类的,如果父子方法名一样,则执行子方法的
    Person s2 = new Student();
    Object s3 = new Student();
    s1.run();
    s2.run();  //runStudent;子类重写了父类的方法,则执行子类
    
}
}

package com.oop.demo06;

public class Person {
public void run(){
    System.out.println("run");
}
}


package com.oop.demo06;

public class Student extends Person{
@Override
public void run() {
    System.out.println("runStudent");
}
}

================================================

  • instanceof(类型转换)

      Object object = new Student();
      System.out.println(object instanceof Object);//true
      System.out.println(object instanceof Person);//true
      System.out.println(object instanceof Student); //true
      System.out.println(object instanceof Teacher);//false
      System.out.println(object instanceof String);//false
    
      Person person = new Student();
      //        System.out.println(person instanceof String);//编译错误
          System.out.println(person instanceof Object);//true
      System.out.println(person instanceof Person);//true
      System.out.println(person instanceof Student); //true
      System.out.println(person instanceof Teacher);//false
    
      Student student = new Student();
      System.out.println(student instanceof Object);//true
      System.out.println(student instanceof Person);//true
      System.out.println(student instanceof Student); //true
      //        System.out.println(student instanceof Teacher);//编译报错
    

    // System.out.println(student instanceof String);//编译报错

  • System.out.println(X instanceof Y)//如果左边的类型X和Y之间有父子关系,编译通过,如果X指向的类型和Y类型

  • 基础类型:高转低,强制。低转高,不用

  • 父子类型,父高子低。:父到子强制,子到父直接用。子到父可能会丢失自己本来的方法

    package com.oop.demo07;

    public class Person {

    static {
    System.out.println(“静态代码块”);
    }
    {
    System.out.println(“匿名代码块”);
    }
    public Person(){
    System.out.println(“构造方法”);
    }

    public static void main(String[] args) {
    Person person1 = new Person(); //静态代码块 匿名代码块 构造方法

      Person person2 = new Person();      //匿名代码块  构造方法
    

    }
    }

==================================================

package com.oop.demo07;

public class Student {

private static int age;//静态变量
private double score;//非静态变量
public void run(){
    go();
}
public static void go(){

}
public static void main(String[] args) {
    Student student = new Student();

    System.out.println(Student.age);
    //      System.out.println(Student.score);//报错
        System.out.println(student.age);
    System.out.println(student.score);

    go();//静态的方法,是与类一起加载的,可以直接调用
}
}









package com.oop.demo07;

import static java.lang.Math.random;

public class Test {

public static void main(String[] args) {
    System.out.println(random());
}
}
  • 抽象类

    package com.oop.demo08;

    //abstract抽象类

    public abstract class Action {

    public abstract void dosomething();
    //抽象方法必须在抽象类中
    //抽象类可以写普通方法
    //new不能抽象类,只能靠子类去实现它
    public Action() {
    }
    }

========================

package com.oop.demo08;

//抽象类的方法需要由子类实现,如果子类也是抽象的,就需要孙子实现

//extends只能单继承,而接口可以多继承

public class A extends Action{

@Override
public void dosomething() {

}
}
  • 普通类:具体实现
  • 抽象类:具体实现+规范(抽象方法)
  • 接口:规范,自己无法写方法,接口就是规范,本质是契约。
  • 约束和实现分离:面向接口编程
  • OO的精髓,是对抽象的抽象,最能体现这一点的是接口
  • 接口的作用
    • 约束

    • 定义一些方法,让不同的人可以实现相同的方法

    • pulic abstract

    • public static final

    • 接口不可被实例化,没有构造方法

    • implments可以实现多个接口

    • 必须要重写接口中的方法

      package com.oop.demo09;

      //extends抽象类

      //interface接口,接口都要有实现类

      //实现接口的类,就要重写接口中的方法

      public interface UserService {

      //接口中的所有定义都是抽象的public abstract
      void add(String name);
      void delete(String name);
      }

      package com.oop.demo09;

      public interface TimeService {
      void timer();
      }

===================================

package com.oop.demo09;

//类可以实现接口implements接口

public class UserServiceImpl implements UserService,TimeService{

@Override
public void add(String name) {

}

@Override
public void delete(String name) {

}

@Override
public void timer() {

}
}
  • 内部类:在A类中在定义一个B类:成员内部类,静态内部类,局部内部类,匿名内部类

    package com.oop.demo10;

    public class Outer{

    private int id = 10; //如果是static类型,那么getId就无法拿到,因为static是和类一起加载的
    public void out(){
    System.out.println(“这是外部类的方法”);
    }
    public class Inner{
    public void in(){
    System.out.println(“这是内部类的方法”);
    }
    public void getId(){
    System.out.println(id);
    }
    }
    }

    package com.oop;

    import com.oop.demo10.Outer;

    public class Application {
    public static void main(String[] args) {
    Outer obj1 = new Outer();
    obj1.out();
    Outer.Inner obj2 = obj1.new Inner();
    obj2.in();
    obj2.getId();
    }
    }

===============================

package com.oop.demo10;

public class Outer{

//局部内部类
public void method(){
    class Inner{
        public void in(){
            
        }
    }
}
}

//一个java中不能有两个并列的public class
  • 匿名内部类:
  package com.oop.demo10;

  public class Test {
      public static void main(String[] args) {
          new Apple().eat();//没有名字初始化类,匿名
          UserService userService = new UserService(){

              @Override
              public void hello() {

              }
          };
      }
  }
  class Apple{
      public void eat(){
          System.out.println("eat");

      }
  }
  interface UserService{
      void hello();
  }

异常

  • Exception
  • 异常的分类
    • 检查性异常:例如找一个文件,但是文件不存在,编译时不可忽略
    • 运行时异常:在编译时可以忽略。1/0;ClassNotFound;NullPoint;UnkownType;下标越界
  • 错误ERROR:错误不是异常,例如StackOverFlow,OutOfMemory均属于jvm错误,编译时检查不到。ERROR通常是致命的错误。Exception是可以被处理的。AWT错误
  • throwable 包括exception和error
  • 抛出异常,捕获异常
  • 异常处理的五个关键字:try,catch,finally,throw,throws
package com.exception;

public class Test {
    public static void main(String[] args) {
        int a= 1;
        int b = 0;
        try {
            System.out.println(a/b);
        } catch (ArithmeticException e){//catch(想捕获的类型)catch(throwable e)
            System.out.println("b不可以为0");
        } finally {		//可以写多个catch,第一个捕获到了,下面的就不执行了,范围由小到大
            System.out.println("finally");
        }
    }
}

  • =====================
package com.exception;

public class Test {
    public static void main(String[] args) {
        int a= 1;
        int b = 0;
        try {
            new Test().a();
        } catch (ArithmeticException e){		//必须是数学方面的异常才可捕获,否则还是异常	
            System.out.println("b不可以为0");
        } finally {					//无论怎样都会执行
            System.out.println("finally");
        }
    }
    public void a(){
        b();
    }
    public void b(){
        a();
    }
}

  • 光标放在一行,ctrl+alt+T,则可以快速生成try catch(还有if-else之类的)自动包裹起来
package com.exception;

public class Test2 {
    public static void main(String[] args) {
        try {
            new Test2().test(1,0);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        } finally {
        }

    }
    public void test(int a ,int b) throws ArithmeticException{
        if(b == 0){
            throw new ArithmeticException();//主动抛出异常,一般在方法中使用
        }
    }
}

package com.exception.demo02;

public class Test {
    //
    static void test(int a) throws MyException{
        if(a > 10){
            throw new MyException(a);
        }
        System.out.println("OK");
    }

    public static void main(String[] args) {
        try {
            test(11);
        } catch (MyException e) {
            System.out.println("haha"+e);
        }
    }
}



package com.exception.demo02;
//自定义异常
public class MyException extends Exception{
    //
    private int detail;

    public MyException(int a) {

        this.detail = a;
    }

    @Override
    public String toString() {
        return "MyException{q" + + detail + '}';
    }
}

  • 在多重catch中,最后增加catch(Exception),防止漏

常用类

  • Object类,String类,StringBuffer类,StringBuilder类,Math类,Random类,File类,包装类,Data类
    • Object:hashcode();toString();clone();getClass();equals();
    • Math类
    • Random类
    • File类:创建,查看,修改,删除文件
    • 包装类:自动装箱和拆箱
    • Data类:Data,Calendar,SimpleDataFormat
    • String :不可变性 操作量简单
      • String str = ‘a’+1+2
      • String str =“a”+1+2
      • String str = 1+2+“a”
    • StringBuffer:可变长用append() 多线程数据量较大 效率低,安全
    • String Builder:单线程数据量大,效率高,不安全
这篇关于Java拓展的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!