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拓展的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程

Java拓展

文章目录

Java拓展

预科

入门

基础

流程控制

方法Method

数组

面向对象

异常

常用类

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯