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"); } } -
Java中只有单继承，没有多继承。一个儿子只有一个爸爸，一个爸爸可以有多个儿子，儿子间接继承爷爷的，且私有private不可以继承
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); } }
==========================
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拓展的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
-
Springboot应用的多环境打包入门11-23
-
Springboot应用的生产发布入门教程11-23
-
Python编程入门指南11-23
-
Java创业入门：从零开始的编程之旅11-23
-
Java创业入门：新手必读的Java编程与创业指南11-23
-
Java对接阿里云智能语音服务入门详解11-23
-
Java对接阿里云智能语音服务入门教程11-23
-
JAVA对接阿里云智能语音服务入门教程11-23
-
Java副业入门：初学者的简单教程11-23
-
JAVA副业入门：初学者的实战指南11-23
-
JAVA项目部署入门：新手必读指南11-23
-
Java项目部署入门：新手必看指南11-23
-
Java项目部署入门：新手必读指南11-23
-
Java项目开发入门：新手必读指南11-23
-
JAVA项目开发入门：从零开始的实用教程11-23
栏目导航
