学习Java的一些笔记

  • 前言
    • java中字符串的比较
    • Stream 流之 sorted
    • 运算符
    • Java包（package）的命名规范&规则
    • SWITCH CASE
    • java中import作用
    • 代码规范
    • 常用方法
    • Scanner
    • Math
    • Arrays
    • 权限修饰符/static
    • 类
    • Java面向对象的理解
    • String创建对象的两种方式
    • JAVA中方法的调用
    • 构造器
    • THIS/super
    • MVC模型模型层 model 主要处理数据
    • 继承
    • JavaBean
    • 多态概述
    • 可变参数
    • throws
    • 包装类
    • 单例设计模式
    • 代码块
    • final
    • 抽象类与抽象方法/抽象类的匿名子类
    • 接口
    • 内部類
    • 异常
    • IDEA操作
    • 多线程

前言

都是我自己在学习java基础过程中的一些笔记，汇总收录一下。因为当时哪里有问题就记哪里，内容比较乱，有一些部分都是浅浅的记录了一下。

java中字符串的比较

- java中字符串的比较：==我们经常习惯性的写上if(str1==str2)，这种写法在java中可能会带来问题example1:String a="abc";String b="abc"那么a==b将返回true。因为在java中字符串的值是不可改变的，相同的字符串在内存中只会存一份，所以a和b指向的是同一个对象；example2：String a=newString("abc"); String b=newString("abc");那么a==b将返回false，此时a和b指向不同的对象。
- 用equals方法比较的是字符串的内容是否相同example：String a=newString("abc"); String b=newString("abc");a.equals(b);将返回true。
- object 的equals 相当于两个对象 ==
String,Date,File,包装类都重写了equals方法/toString方法，比较的是实体内容

Stream 流之 sorted

sorted(Comparator<? super T> comparator)
1   public class StreamDemo {2       public static void main(String[] args) {3           List<Person> personList = Arrays.asList(
4                   new Person(1, "大毛", 30, 175),
5                   new Person(2, "二毛", 25, 170),
6                   new Person(3, "三毛", 25, 170),
7                   new Person(4, "小毛", 20, 163));
8
9           // 获取 person 类型流
10          Stream<Person> personStream = personList.stream();
11          // 将 person 类型流转换成 age 类型流
12          Stream<Integer> ageStream = personStream.map((item) -> item.getAge());
13          // 对 age 类型流进行定制排序
14          // 定制排序需要实现 Comparator<? super T> comparator 接口,该接口有一个抽象方法
15          // int compare(T o1, T o2),如果 o1-o2 代表正序排序,o2-o1 代表倒序排序
16          Stream<Integer> sortedStream = ageStream.sorted(((o1, o2) -> o2-o1));
17          // 遍历新流 sortedStream 中的元素
18          sortedStream.forEach(System.out::println);
19      }
20  }

运算符

instanceof  检查是否类的对象           “hello” instanceof String        -> true前++（++a)与后++(a++)的区别:
++a会先进行a的+1，再进行赋值或者比较
a++ 反之，先赋或参加表达式，再+1位运算符号a<<x               表示数值的二机制形式，向左移动X位，后面补x个零，左一位数字变大两倍为原来的两倍
a>>x               同理右移等与/2，拿符号位补，负数拿1补
a>>>x       无符号，都用0补
&                     两个数的补码一一对应，都为1，结果为1
|                      两个数的补码一一有一个为1，结果为1
^                      两个数的补码一一只有两个数不相同，结果为1
~                取反，包括符号位三元运算符
（a>b）？a:b;            表达式为真结果为a,为假结果为b

Java包（package）的命名规范&规则

java中的打包机制是为了防止程序多个地方出现相同的名字而将局部程序限定在一块的机制
如不同地区存在 同名同姓的人，为解决这个问题，我们不同地方的所有人（程序）分别打包。调用A的时候分别带上a.A或者是b.A。这样就不会出错了。
打包其实就是新建了一个文件夹，然后把需要打包的程序放在这个文件夹下面。
要注意​：1. package必须是程序中可执行的第一行代码2. package语句只能有一句3. package命名要求包含的所有字符均为小写，同时不能有特殊字符4. package可以有多层，每一层有.隔开，例如：package china.hubei.wuhan;（China是一个文件夹，hubei是china下的一个文件夹，wuhan是hubei文件夹下的一个文件夹5. package语句后面的分号不要掉。​6. 包的路径符合所开发的系统模块的定义，比如生产对生产，物资对物资，基础类对基础类。7. 如果定义类的时候没有使用package,那么java就认为我们所定义的类位于默认包里面(default package)。• 个人的项目命名：○ indi ：
个体项目（individual），指个人发起，但非自己独自完成的项目，可公开或私有项目，copyright主要属于发起者。
包名为“indi.发起者名.项目名.模块名……”○ onem ：
单人项目（one-man），推荐用indi，指个人发起，但非自己独自完成的项目，可公开或私有项目，copyright主要属于发起者。
包名为“onem.发起者名.项目名.模块名……”○ pers ：
个人项目（personal），指个人发起，独自完成，可分享的项目，copyright主要属于个人。
包名为“pers.个人名.项目名.模块名.……”○ priv ：
私有项目（private），指个人发起，独自完成，非公开的私人使用的项目，copyright属于个人。
包名为“priv.个人名.项目名.模块名.……”• 团体的项目命名○ team：
团队项目，指由团队发起，并由该团队开发的项目，copyright属于该团队所有。
包名为“team.团队名.项目名.模块名.……”
com ：
公司项目，copyright由项目发起的公司所有。
包名为“com.公司名.项目名.模块名.……”

SWITCH CASE

switch case表达式只能是6种类型：byte，short，char，int，枚举，String
不加break会往下继续输出，不会跳出
case后可接以上几种类型，必须是明确的
switch(表达式){case 常量1：xxxxx；break；case 常量2：xxxx；default：xxxx；
}

java中import作用

有三种包在JVM运行时会自动被导入：①当前主类所在的包
②java.lang包
③没有名字的包
Scanner类位于java.util包中，它不在上述三种情况中，因此需要导入。
Math类位于java.lang包中，属于情况2，因此无需导入。
自定义的类如果和当前主类位于同一个包下，属于情况1，也无需导入；否则，仍然需要导入
如果不同包有同名类需要导入，必须全类名导入（包名+类名）不能importimport static 可以导入指定类/接口的静态结构  不是导入类了
import static java.lang.System.out; 然后输出可以直接 out.println(xxx);package
C/C++ 的 #include会把所包含的内容在编译时添加到程序文件中，而java的import则不同。这里我们先了解一下Java 的 package 到底有何用处。package名称就像是我们的姓，而class名称就像是我们的名字 。package和package的附属关系用"."来连接，这就像是复姓。比如说 java.lang.String就是复姓 java.lang，名字為 String 的类别；java.io.InputStream 则是复姓 java.io，名字為 InputStream的类别。Java 会使用 package 这种机制的原因也非常明显，就像我们取姓名一样 ，光是一间学校的同一届同学中，就有可能会出现不少同名的同学，如果不取姓的话，那学校在处理学生资料，或是同学彼此之间的称呼，就会发生很大的困扰。相同的，全世界的 Java 类数量，恐怕比日本人还多，如果类别不使用package名称，那在用到相同名称的不同类时， 就会产生极大的困扰。所以package这种方式让极大降低了类之间的命名冲突。Java 的package名称我们可以自己取，不像人的姓没有太大的选择 ( 所以出现很多同名同姓的情况 )，如果依照 Sun 的规范来取套件名称，那理论上不同人所取的套件名称不会相同 ( 需要的话请参阅 “命名惯例” 的相关文章 )，也就不会发生名称冲突的情况。可是现在问题来了，因為很多package的名称非常的长，在编程时，要使用一个类要将多个包名.类名完全写出，会让代码变得冗长，减低了简洁度。例如java.io.InputStream is = java.lang.System.in;
java.io.InputStreamReader isr= new java.io.InputStreamReader(is);
java.io.BufferedReader br = new java.io.BufferedReader(isr);
显得非常麻烦，于是Sun公司就引入了import。import
import就是在java文件开头的地方，先说明会用到那些类别。
接着我们就能在代码中只用类名指定某个类，也就是只称呼名字，不称呼他的姓。首先，在程序开头写：import java.lang.System;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;
于是我们就可以在程序中这样写到：InputStream = System.in;
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
一个java文件就像一个大房间，我们在门口写着在房间里面的class的姓和名字，所以在房间里面提到某个class就直接用他的名字就可以。例如：System 就是指 java.lang.System，而 InputStream 就是指 java.io.InputStream。但是如果一个java文件里面有多个同个“姓”，即包名相同的类（例如上面的InputStream，InputStreamReader，BufferedReader都是java.io中的类），我们一一写出显得比较繁杂，所以Sun就让我们可以使用import java.lang.*;
import java.io.*;
表示文件里面说到的类不是java.lang包的就是java.io包的。编译器会帮我们选择与类名对应的包。那我们可不可以再懒一点直接写成下面声明呢？import java.*;
1
历史告诉我们，这样是不行的。因為那些类别是姓 java.io 而不是姓 java。就像姓『诸葛』的人应该不会喜欢你称他為『诸』 先生吧。这样写的话只会将java包下的类声明，而不不会声明子包的任何类。这里注意，java.lang包里面的类实在是太常太常太常用到了，几乎没有类不用它的， 所以不管你有没有写 import java.lang，编译器都会自动帮你补上，也就是说编译器只要看到没有姓的类别，它就会自动去lang包里面查找。所以我们就不用特别去 import java.lang了。一开始说 import 跟 #include 不同，是因为import 的功能到此為止，它不像#include 一样，会将其他java文件的内容载入进来。import 只是让编译器编译这个java文件时把没有姓的类别加上姓，并不会把别的文件程序写进来。你开心的话可以不使用import，只要在用到类别的时候，用它的全部姓名来称呼它就行了(就像例子一开始那样)，这样跟使用import功能完全一样。import的两种导入声明
单类型导入(single-type-import)
（例:import java.util.ArrayList; ）
按需类型导入(type-import-on-demand)
（例:import java.util.*;）
有如下属性：java以这样两种方式导入包中的任何一个public的类和接口(只有public类和接口才能被导入)上面说到导入声明仅导入声明目录下面的类而不导入子包，这也是为什么称它们为类型导入声明的原因。导入的类或接口的简名(simple name)具有编译单元作用域。这表示该类型简名可以在导入语句所在的编译单元的任何地方使用.这并不意味着你可以使用该类型所有成员的简名,而只能使用类型自身的简名。
例如: java.lang包中的public类都是自动导入的,包括Math和System类.但是,你不能使用它们的成员的简名PI()和gc(),而必须使用Math.PI()和System.gc().你不需要键入的是java.lang.Math.PI()和java.lang.System.gc()。程序员有时会导入当前包或java.lang包，这是不需要的，因为当前包的成员本身就在作用域内,而java.lang包是自动导入的。java编译器会忽略这些冗余导入声明(redundant import declarations)。即使像这样
import java.util.ArrayList;
import java.util.*;
多次导入,也可编译通过。编译器会将冗余导入声明忽略.static import静态导入
在Java程序中，是不允许定义独立的函数和常量的。即什么属性或者方法的使用必须依附于什么东西，例如使用类或接口作为挂靠单位才行（在类里可以挂靠各种成员，而接口里则只能挂靠常量）。如果想要直接在程序里面不写出其他类或接口的成员的挂靠单元，有一种变通的做法 :
将所有的常量都定义到一个接口里面，然后让需要这些常量的类实现这个接口（这样的接口有一个专门的名称，叫(“Constant Interface”)。这个方法可以工作。但是，因为这样一来，就可以从“一个类实现了哪个接口”推断出“这个类需要使用哪些常量”，有“会暴露实现细节”的问题。于是J2SE 1.5里引入了“Static Import”机制，借助这一机制，可以用略掉所在的类或接口名的方式，来使用静态成员。static import和import其中一个不一致的地方就是static import导入的是静态成员，而import导入的是类或接口类型。如下是一个有静态变量和静态方法的类package com.assignment.test;public class staticFieldsClass {static int staticNoPublicField = 0; public static int staticField = 1;public static void staticFunction(){}
}
平时我们使用这些静态成员是用类名.静态成员的形式使用，即staticFieldsClass.staticField或者staticFieldsClass.staticFunction()。现在用static import的方式：//**精准导入**
//直接导入具体的静态变量、常量、方法方法，注意导入方法直接写方法名不需要括号。
import static com.assignment.test.StaticFieldsClass.staticField;
import static com.assignment.test.StaticFieldsClass.staticFunction;//或者使用如下形式：
//**按需导入**不必逐一指出静态成员名称的导入方式
//import static com.assignment.test.StaticFieldsClass.*;public class StaticTest {public static void main(String[] args) {//这里直接写静态成员而不需要通过类名调用System.out.println(staticField);staticFunction();}
}这里有几个问题需要弄清楚：Static Import无权改变无法使用本来就不能使用的静态成员的约束，上面例子的StaticTest和staticFieldsClass不是在同一个包下，所以StaticTest只能访问到staticFieldsClass中public的变量。使用了Static Import也同样如此。导入的静态成员和本地的静态成员名字相同起了冲突，这种情况下的处理规则，是“本地优先。不同的类（接口）可以包括名称相同的静态成员。例如在进行Static Import的时候，出现了“两个导入语句导入同名的静态成员”的情况。在这种时候，J2SE 1.5会这样来加以处理：如果两个语句都是精确导入的形式，或者都是按需导入的形式，那么会造成编译错误。如果一个语句采用精确导入的形式，一个采用按需导入的形式，那么采用精确导入的形式的一个有效。大家都这么聪明上面的几个特性我就不写例子了。static import这么叼那它有什么负面影响吗？答案是肯定的，去掉静态成员前面的类型名，固然有助于在频繁调用时显得简洁，但是同时也失去了关于“这个东西在哪里定义”的提示信息，理解或维护代码就呵呵了。
但是如果导入的来源很著名（比如java.lang.Math），这个问题就不那么严重了。按需导入机制
使用按需导入声明是否会降低Java代码的执行效率?绝对不会!一、import的按需导入import java.util.*;public class NeedImportTest {public static void main(String[] args) {ArrayList tList = new ArrayList();}
}
编译之后的class文件 ://import java.util.*被替换成import java.util.ArrayList
//即按需导入编译过程会替换成单类型导入。
import java.util.ArrayList;public class NeedImportTest {public static void main(String[] args) {new ArrayList();}
}二、static import的按需导入import static com.assignment.test.StaticFieldsClass.*;
public class StaticNeedImportTest {public static void main(String[] args) {System.out.println(staticField);staticFunction();}
}
上面StaticNeedImportTest 类编译之后 ://可以看出 ：
//1、static import的精准导入以及按需导入编译之后都会变成import的单类型导入
import com.assignment.test.StaticFieldsClass;public class StaticNeedImportTest {public static void main(String[] args) {//2、编译之后“打回原形”，使用原来的方法调用静态成员System.out.println(StaticFieldsClass.staticField);StaticFieldsClass.staticFunction();}
}
附加
这是否意味着你总是可以使用按需导入声明?
是,也不是!在类似Demo的非正式开发中使用按需导入声明显得很有用。然而,有这四个理由让你可以放弃这种声明:编译速度：在一个很大的项目中，它们会极大的影响编译速度.但在小型项目中使用在编译时间上可以忽略不计。
命名冲突：解决避免命名冲突问题的答案就是使用全名。而按需导入恰恰就是使用导入声明初衷的否定。
说明问题：毕竟高级语言的代码是给人看的，按需导入看不出使用到的具体类型。
无名包问题：如果在编译单元的顶部没有包声明，Java编译器首选会从无名包中搜索一个类型，然后才是按需类型声明。如果有命名冲突就会产生问题。
Sun的工程师一般不使用按需类型导入声明.这你可以在他们的代码中找到:
在java.util.Properties类中的导入声明:import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.security.AccessController;
import java.security.PrivilegedAction;
可以看到他们用单类型导入详细的列出了需要的java.io包中的具体类型。

代码规范

包名全小写，
类名首字母大写，
方法小陀峰第一个首字母小写后面大写，
变量小陀峰第一个首字母小写后面大写，
常量（不可修改的值final）命名的格式：每个字母都得大写，每个单词间用下划线隔开

常用方法

charAt          从字符串中获取单个字符，charAt(x),xx.equals(yy)  比较两个内容是否相等，常用于字符串，相等返回TURE

Scanner

读入字符串
1. 只是Sanner类在在调用方法时在读屏幕上的输入，读入到指定地方就停止，将读入的数据返回
2. *next()读取到空白停止，在读取输入后将光标放在同一行中给下一个scanner方法继续读，如果有溢出的话，（比如输入 11 22 33回车，next（）只会获取11（空格），还剩下的22 33回车可以继续被下一个scanner类的方法获取
3.  *nextLine()读取到回车停止 ，在读取输入后将光标放在下一行，给下一个scanner方法继续读，如果有溢出的话• hasNext（）Returns true if this scanner has another token in its input. This method may block while waiting for input to scan. The scanner does not advance past any input.
有任何字符返回ture，这个方法会阻塞，等待输入后才可以运行（必须输入非空字符）
• next（）返回下一个输入（空格也算），把指针移向返回后的地方
• nextLine（） 把指针移动到下一行 让然后取出当前这一行的输入
• hasNextLine（） 输入器中有一行（空行也算=只按个回车）即为true，这个方法会阻塞，等待输入后才可以运行。This method may block while waiting for input，这个方法会阻塞，等待输入后才可以运行。

Math

/** *Math.sqrt()//计算平方根*Math.cbrt()//计算立方根*Math.pow(a, b)//计算a的b次方*Math.max( , );//计算最大值*Math.min( , );//计算最小值* abs求绝对值 * ceil天花板的意思，就是返回大的值* floor地板的意思，就是返回小的值 * random 取得一个大于或者等于0.0小于不等于1.0的随机数 * rint 四舍五入，返回double值 * 注意.5的时候会取偶数    异常的尴尬=。=* round 四舍五入，float时返回int值，double时返回long值 生成[0, 1)的随机数Math.random()-------------------------------------------------------------
生成[0, Num)Math.random() * Num-----------------------------------------------------------例如：生成[0, 5)的随机数  Match.random() * 5-----------------------------------------------------------
生成[a, b)(int)(Math.random() * (b - a))  + a-------------------------------------------------------------例如：生成[5, 11)的随机数(Match.random() * (11 - 5)) + 5生成[a, b](int)(Math.random() * (b - a + 1)  + a-------------------------------------------------------------      例如：生成[5, 11]的随机数(Math.random() * ((11 - 5) + 1)) + 5

Arrays

boolean equals（int[]a,int[] b)
char型数组可以直接输出

权限修饰符/static

public,private,缺省
1、public：public表明该数据成员、成员函数是对所有用户开放的，所有用户都可以直接进行调用2、private：private表示私有，私有的意思就是除了class自己之外，任何人都不可以直接使用，私有财产神圣不可侵犯嘛，即便是子女，朋友，都不可以使用。3、protected：protected对于子女、朋友来说，就是public的，可以自由使用，没有任何限制，而对于其他的外部class，protected就变成private。static         表示静态的意思，可以看作全局变量，可以加在方法，变量后面，可以通过类.变量/类.方法直接调用，静态方法只用来调用，不能获取类其中的属性。
静态方法只能调用静态方法，譬如（main方法）
声明为static的方法有以下几条限制：
•它们仅能调用其他的static 方法。
•它们只能访问static数据。
•它们不能以任何方式引用this 或super（关键字super 与继承有关，在下一章中描述）。
如果你需要通过计算来初始化你的static变量static方法不能重写，静态方法主要是给类.方法用的，
重写的目的在于父类引用可以根据子类对象的运行时实际类型不同而调用不同实现代码，从而表现出多态。并且，静态方法无需创建对象即可使用，而重写的方法发挥作用，需要父类引用，和（不同的）子类对象。这里说一下静态变量和实例变量的区别：
两者的区别是：
对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的），一个地方修改，大家伙改咯。存在方法区的静态域中
对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。static代码块static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。一个Java源文件中最多只能有一个public类，当有一个public类时，源文件名必
须与之一致，否则无法编译，如果源文件中没有一个public类，则文件名与类中没有一致性要求。
至于main()不是必须要放在public类中才能运行程序。class只能被public和省略修饰
public可以在任意地方被访问
default类只能在同一个包内被访问
import不同的包的类class，只有public属性可以直接使用被static修饰的成员变量和成员方法是独立于该类的，他不依赖于特定的实例变量，被所有实例共享。所有的实例对其的修改都会导致其他实例的变化！

类

类的属性都有初始化值（同数组）
整形（short，long，int,byte):   0
浮点型（float，double）  0.0
字符型（char） 0或’\u0000'
布尔型（boolean）  false
引用型（类，数组，接口）    null每一个源文件中，只能有一个public类
如果文件中只写了一个类，那文件名与类名必须一致，大小写也要一致。
如果文件中定义了多个类(仅有一个public的)，那么文件名必须与public那个类名一致在声明了自定义类的数组之后，对每一个数组元素的初始化，都要为其new一个对象出来使得指针指向该对象，Java语言本身是不提供在自定义类数组声明时候自动创建新对象的方式的。类只能被public和缺省修饰；在类中给属性赋值，仅能通过初始化，构造器，set方法，
1.默认初始化
2.显示初始化、代码块中初始化
3.构造器中初始化
4.通过“对象.属性”或“对象.方法”井下赋值类只加载一次！！
什么时候加载类：当第一次需要类信息时，
原则：延迟加载，能不加载就不加载li
类实例化时，会调用一次无参构造器（一般），

Java面向对象的理解

变量是基本数据类型，赋值是变量保持的数据值
变量是引用数据类型，赋值是保存数据的地址值
String比较特殊，字符串在常量池里

值的传递（给方案的形参赋予一个实参）
如果参数是基本数据类型，实参赋予的是实际数据值
如果参数是引用数据类型，实参赋予的是对应的地址值，可以直接修改
链接: link

String创建对象的两种方式

String创建对象的两种方式
String类是引用数据类型，该类实例化方式有两种：1、直接赋值：String str1 = "abc";
String str2 = "abc";
System.out.println(str1 == str2);  //返回true。
//因为String类是引用数据类型，“==”比较的是两个引用变量的地址；如果是基本类型变量，则比较的是变量值。
直接赋值会进行以下过程：
① 执行“String str1 = ”abc“;”后，JVM在常量池中开辟空间存放一个abc字符串空间并让str1指向该对象。
② 执行“String str2 = ”abc“;”时，JVM会先检查常量池中是否已经存在了一内容为abc的空间，如果存在就直接让str2指向该空间，否则就会在开辟一个新的空间存放该字符串。
③ 所以创建str2的时候，因为常量池中已经有字符串"abc"，所以直接让str2指向该空间。相当于：String str2 = str1;2、构造方法实现其实例化：String name1 = new String("xubing");
String name2 = new String("xubing");
System.out.println(name1 == name2); //因为两个变量指向的地址不一样，所以返回false。
创建新对象会进行以下过程：
① 执行“String name1 = new String(“xubing”);”时，JVM直接创建一个新的对象并让name1指向该对象；
② 执行“String name2 = new String(“xubing”);”时，JVM再次创建一个新的对象并让name2指向该对象；
③ 所以name1与name2指向不同的对象，即地址不同。

JAVA中方法的调用

JAVA中方法的调用主要有以下几种：
1.非静态方法
非静态方法就是没有 static 修饰的方法，对于非静态方法的调用，是通过对 象来调用的，表现形式如下。
对象名.方法（）
eg：
public class InvokeMethod{public static void main(String[] args){InvokeMethod in = new InvokeMethod();in.t1();}public void t1(){System.out.printfln("t1");}
}
2.调用静态方法
静态方法就是用 static 修饰的方法，静态方法的调用是通过类名来调用的， 表现形式如下：
类名.方法()
eg:
public class InvokeMethod{public static void main (String[] args){InvokeMethod.t2();}public static void t2(){System.out.println("static t2....");}
}
3.方法与方法之间的调用
方法与方法之间的调用，主要是在一个方法内部如何调用其他方法。
（1）静态方法内部调用其他方法
如果在本类当中，静态方法可以直接调用静态方法，
除了在 main 方法中，还可以在自定义的静态方法中直接调用。
如果在本类当中是非静态方法，就必须通过对象来调用。
public class InvokeMethod{public static void main (String[] args){t2();}public static void t2(){System.out.println("static t2...");}public static void t1(){//静态方法调用非静态方法需通过对象来调用//InvokeMethod in =new InvokeMethod();//in.t2();t2();System.out.println("static t1");}
}
如果不在一个类当中，静态方法调用其他类中的静态方法，必须通过
类名.静态方法（）；
如果在不同类当中，静态方法调用其他类的非静态方法，需要导入该类中的包，以及通过创建对象调用。
（2）非静态方法内部调用
如果在本类中，非静态方法可以直接调用静态方法与非静态方法。
在不同类中，非静态方法调用其他类的静态方法，需要通过导入该类中的包，并且需要通过类名来调用
在不用类中，非静态方法调用其他类的非静态方法时，需要导入该类中的包，还需要通过创建对象来调用。
我曾某人总结一下：就是静态方法的调用，在其他类里，不需要创建实例，直接类名.方法；非静态方法的调用，在其他类里，必须new一个实例，在本类中，静态方法只能直接调用静态方法，非静态要new实例在本类中，非静态方法，可以直接调用静态和非静态方法

构造器

1，创建对象
new +构造器 就是创建对象
2，给属性初始化赋值
class Zxx（）{private int a ;public Zxx（）{ int a}
}属性赋值的先后：
1，默认初始化
2，显示初始化
3，构造器中赋值
4，对象。方法/对象.属性 赋值Public protected private修饰常用使用构造器时需要记住：1.构造器必须与类同名（如果一个源文件中有多个类，那么构造器必须与公共类同名）
2.每个类可以有一个以上的构造器
3.构造器可以有0个、1个或1个以上的参数
4.构造器没有返回值
5.构造器总是伴随着new操作一起调用
6.不添加任何构造器会默认有空的构造器
继承与构造器
使用super调用父类构造器的语句必须是子类构造器的第一条语句，后面的可以用this（），不用默认父类无参构造器 super（）；所有构造器的首行，不是super（形参）/this（形参），不填默认父类的空参构造器super（）为什么加上super？
Java的构造器并不是函数，所以他并不能被继承，这在我们extends的时候写子类的构造器时比较的常见，即使子类构造器参数和父类的完全一样，我们也要写super就是因为这个原因。
如果子类构造器没有显式地调用父类的构造器，则将自动调用父类的默认（没有参数）的构造器。如果父类没有不带参数的构造器，并且在子类的构造器中又没有显式地调用父类的构造器，则java编译器将报告错误一。父类构造器1.1隐式调用和显式调用当调用某个类的构造器来创建java对象时，系统总会先调用最顶层父类的非静态初始化代码块进行初始化，接着会调用父类的一个或多个构造器执行初始化，最后返回本类的实例。调用父类哪个构造器执行初始化分为三类：1.子类构造器执行体的第一行代码使用super显式调用父类构造器，系统将根据super调用里传入的实参列表来 确定调用父类的哪个构造器。2.子类构造器执行体的第一行代码使用this显式调用本类重载的构造器，系统将根据this调用里传入的实参列 表来 确定调用本类的另一个构造器。3.子类构造器执行体中既没有super和this调用。系统将会在执行子类构造器之前，隐式调用父类无参数的构 造器。注：super调用和this调用都只能在构造器中使用，而且super调用和this调用都必须作为构造器的第一行代码，因此构造器中的super调用和this调用最多只能使用其中之一，而且最多只能调用一次。继承关系的细节
1，子类拥有父类的属性和方法，但是对于父类的私有属性（private修饰），子类是无权访问的，只是拥有。
2，父类可以什么都不写，但是此时程序会自动生成一个无参构造函数。而如果我们自己写了一个有参构造函数，那么程序就不会再帮我们自动生成无参构造函数了，需要自己写，否则程序会报错。至于为什么会报错接着往下看；
3，当我们使用子类实例化的时候，如果我们没有显式的使用super去调用父类中的构造函数，那么程序会自动的帮我们去调用父类中的无参构造函数进行初始化工作（此时如果出现上面那种情况，自己手写了有参构造但是没有写无参构造，那么程序不就出错了嘛！），再调用子类的有参/无参构造器。
4，为什么是调用父类的无参构造器而不是有参呢？回答是：不管子类的构造器有没有参数，因为子类继承的是父类的属性和方法，只调用父类的无参构造器就可以继承父类的属性和方法，因此不会调用父类的有参构造器。构造方法和实例方法的区别：
一、主要的区别在于三个方面：修饰符、返回值、命名
1、和实例方法一样，构造器可以有任何访问的修饰符，public、private、protected或者没有修饰符   ，都可以对构造方法进行修饰。不同于实例方法的是构造方法不能有任何非访问性质的修饰符修饰，例如static、final、synchronized、abstract等都不能修饰构造方法。
解释：构造方法用于初始化一个实例对象，所以static修饰是没有任何意义的;多个线程不会同时创建内存地址相同的同一个对象，所以synchronized修饰没有意义;
构造方法不能被子类继承，所以final和abstract修饰没有意义。
2、返回类型是非常重要的，实例方法可以返回任何类型的值或者是无返回值（void）,而构造方法是没有返回类型的，void也不行。
3、至于命名就是构造方法与类名相同，当然了实例方法也可以与类名相同,但是习惯上我们为实例方法命名的时候通常是小写的,另一方面也是与构造方法区分开。
而构造方法与类名相同,所以首字母一般大写。
下面看几个例子熟悉一下：
public class Sample {  private int x;  public Sample() { // 不带参数的构造方法  this(1);  }  public Sample(int x) { //带参数的构造方法  this.x=x;  }  public int Sample(int x) { //不是构造方法  return x++;  }  }
上面的例子即使不通过注释我们也很容易能区分开的，再看下面一个例子
public class Mystery {  private String s;  public void Mystery() { //不是构造方法  s = "constructor";  }  void go() {  System.out.println(s);  }  public static void main(String[] args) {  Mystery m = new Mystery();  m.go();  }
}
程序执行的结果为null，虽然说Mystery m = new Mystery();调用了Mystery 类的构造方法，但是public void Mystery()并不是构造方法，他只是一个普通的实例方法而已,那该类的构造方法哪去了呢？
二、说到这就得说一下java的默认构造方法
我们知道,java语言中规定每个类至少要有一个构造方法,为了保证这一点，当用户没有给java类定义明确的构造方法的时候,java为我们提供了一个默认的构造方法,这个构造方法没有参数,修饰符是public并且方法体为空。
其实默认的构造方法还分为两种,一种就是刚刚说过的隐藏的构造方法,另一种就是显示定义的默认构造方法.
如果一个类中定义了一个或者多个构造方法,并且每一个构造方法都是带有参数形式的,那么这个类就没有默认的构造方法,看下面的例子。
public class Sample1{}  public class Sample2{  public Sample2(int a){System.out.println("My Constructor");}
}  public class Sample3{  public Sample3(){System.out.println("My Default Constructor");}
}
上面的三个类中Sample1有一个隐式的默认构造方法,下列语句Sample1 s1=new Sample()合法;
Sample2没有默认的构造方法,下列语句Sample2 s2=new Sample2()不合法,执行会编译错误
Sample3有一个显示的默认构造方法,所以以下语句Sample3  s3=new Sample3();合法。
三、实例方法和构造方法中this、super的使用.
"this"的用法
实例方法中可以使用this关键字,它指向正在执行方法的类的实例对象,当然static方法中是不可以使用this对象的,因为静态方法不属于类的实例对象;而构造方法中同样可以使用this关键字,构造器中的this是指向同一个对象中不同参数的另一个构造器。让我们来看下面的一段代码：
public class Platypus {  String name;  Platypus(String input) {  name = input;  }  Platypus() {  this("John/Mary Doe");  }  public static void main(String args[]) {  Platypus p1 = new Platypus("digger");  Platypus p2 = new Platypus();  System.out.println(p1.name + "----" + p2.name);  }
}
上面的代码中 类有两个构造器,第一个构造器给类的成员name赋值,第二个构造器调用第一个构造器给类的成员name一个初始值Jonn/Mary Doe
所以程序执行结果：digger----John/Mary Doe
需要注意的两个地方是：
1、构造方法中通过this关键字调用其他构造方法时,那么这句代码必须放在第一行,否则会编译错误。
2、构造方法中只能通过this调用一次其他的构造方法。"super"的用法：
实例方法和构造方法中的super关键字都用于去指向父类,实例方法中的super关键字是去调用父类当中的某个方法,看下面的代码：
class getBirthInfo {  void getBirthInfo() {  System.out.println("born alive.");  }
}  class Platypus1 extends getBirthInfo
{  void getBirthInfo() {  System.out.println("hatch from eggs");  System.out.println("a mammal normally is ");  super.getBirthInfo();  }
}  public class test1 {  public static void main(String[] args) {  Platypus1 p1=new Platypus1();  p1.getBirthInfo();  }
}
上面的例子使用super.getBirthInfo();调用了它的父类的void getBirthInfo()方法。构造器中使用super关键字调用父类中的构造器,看下面的代码：
class getBirthInfo {  getBirthInfo(){  System.out.println("auto");  }  void aa() {  System.out.println("born alive.");  }
}  class Platypus1 extends getBirthInfo
{  Platypus1() {  super();  System.out.println("hatch from eggs");  System.out.println("a mammal normally is ");  }
}  public class test1 {  public static void main(String[] args) {  Platypus1 p1=new Platypus1();  }
}
执行了代码我们就会看到构造器中的super调用了父类的构造方法。类的继承机制使得子类可以调用父类的功能,下面介绍类在继承关系的初始化顺序问题请看实例1:
class SuperClass
{   SuperClass()   {   System.out.println("SuperClass constructor");   }
}
public class SubClass extends SuperClass {  SubClass()   {   System.out.println("SubClass constructor");   }   public static void main(String[] args) {  SubClass sub = new SubClass();   }
}
执行结果：SuperClass constructorSubClass constructor
代码中我们只实例化子类一个对象,但从执行结果上看程序一开始并不是运行子类的构造方法,而是先执行父类的默认构造方法,然后再执行子类的构造方法.所以我们在实例化子类对象时,程序会先调用父类的默认构造方法,然后再执行子类的构造方法。再看实例2：
class SuperClass
{   SuperClass(String str)   {   System.out.println("Super with a string.");   }
}
public class SubClass extends SuperClass
{   SubClass(String str)   {   System.out.println("Sub with a string.");   }   public static void main(String[] args)   {   SubClass sub = new SubClass("sub");   }
}
此程序在JDK下不能编译成功,因为我们在实例化子类对象的时候会先调用其父类默认的构造方法,但是它的父类没有默认的构造方法,所以不能编译成功。
解决办法：
1、在父类中加一个显示的默认构造方法
2、在子类的构造方法中加一句super(str)并且必须在构造器的第一句。
两个办法都可以解决程序编译的问题,但是执行结果是不一样的.
第一种执行结果为:Sub with a string.
第二种执行结果为：Super with a string. Sub with a string.     第二种方法即使父类中有显示的默认构造方法也不会被调用。再看实例三：
class One
{   One(String str)   {   System.out.println(str);   }
}
class Two
{   One one_1 = new One("one-1");   One one_2 = new One("one-2");   One one_3 = new One("one-3");   Two(String str)   {   System.out.println(str);   }
}
public class Test
{   public static void main(String[] args)   {   System.out.println("Test main() start");   Two two = new Two("two");   }
}
执行结果：
Test main() start
one-1
one-2
one-3
two
我们在main方法中实例了一个Two的对象,但是程序在实例Two对象时并没有先调用Two的构造方法,而是先初始化Two类的成员变量,Two类中有三个成员变量,他们都是One类的对象,所以要依次执行One类的构造方法,然后再初始化Two类的对象。
既在实例化类的对象时,类中的成员变量会首先进行初始化,如果其中的成员变量有对象，那么它们也会按照顺序执行初始化工作。在所有类成员初始化完成后，才调用对象所在类的构造方法创建对象。构造方法作用就是初始化。 再看实例四：
class One   {   One(String str)   {   System.out.println(str);   }
}
class Two
{   One one_1 = new One("one-1");   One one_2 = new One("one-2");   static One one_3 = new One("one-3");   Two(String str)   {   System.out.println(str);   }
}
public class Test
{   public static void main(String[] args)   {   System.out.println("Test main() start");   Two two_1 = new Two("two-1");   System.out.println("------------");   Two two_2 = new Two("two-2");   }
}
执行结果：
Test main() start
one-3
one-1
one-2
two-1
------------
one-1
one-2
two-2
结论：如果一个类中有静态对象,那么他会在非静态对象初始化前进行初始化,但只初始化一次。而非静态对象每次调用时都要初始化。再看实例五：
class One
{   One(String str)   {   System.out.println(str);   }
}
class Two
{   One one_1 = new One("one-1");   One one_2 = new One("one-2");   static One one_3 = new One("one-3");   Two(String str)   {   System.out.println(str);   }
}
public class Test
{   static Two two_3 = new Two("two-3");   public static void main(String[] args)   {   System.out.println("Test main() start");   Two two_1 = new Two("two-1");   System.out.println("------------");   Two two_2 = new Two("two-2");   }
}
执行结果：
one-3
one-1
one-2
two-3
Test main() start
one-1
one-2
two-1
------------
one-1
one-2
two-2
结论：程序中主类的静态变量会在main()方法执行前初始化。结果中只输出了一次one-3，这也说明：如果一个类中有静态对象，那么它会在非静态对象前初始化，但只初始化一次。非静态对象每次调用时都要初始化。 总结初始化顺序：
1．主类的静态成员首先初始化。
2．主类的父类的构造方法被调用。
3．主类的非静态对象（变量）初始化。
4．调用主类的构造方法。

THIS/super

 1.区分成员变量和局部变量
2.代表当前对象
3.构造器与构造器之间的调用
就是在构造器中，你需要之前已经定义过的构造器内容，可以在首行this（形参列表）的方式，调用指定其他构造器
THIS()必须在首行，不能闭环调取，与形参同名时，用this可以特指 this.属性 先在当前类中找，没有再去父类找
super      直接去父类

MVC模型模型层 model 主要处理数据

数据对象的封装 model.bean/domain
数据库的操作类 model.dao
数据库 model.db控制层 controller 处理业务逻辑
应用界面相关 controller.activity
存放fragment controlle.fragment
显示列表的适配器 controller.adapter
服务相关的 controller.service
抽取的基类 controller.base视图层 view 显示数据
相关工具类 view.utils
自定义view view.ui

继承

class  a extend b{}
a:子类，派生类，subclass
b:父类。基类，超类，superclass
说明a继承了b（属性和方法）
继承结构中，父类的构造器只能够被调用，而不能被子类继承。 调用父类的构造方法要在子类的构造器中使用super()。如果没有声明一个类的父类，则此类继成于java.lang.Object类父类私有的属性和方法，任然获取了只是因为封装性的问题不能直接调用，可以用get方法一个类只能有一个父类，n多子类static方法不能够重写继承关系的细节
1，子类拥有父类的属性和方法，但是对于父类的私有属性（private修饰），子类是无权访问的，只是拥有。
2，父类可以什么都不写，但是此时程序会自动生成一个无参构造函数。而如果我们自己写了一个有参构造函数，那么程序就不会再帮我们自动生成无参构造函数了，需要自己写，否则程序会报错。至于为什么会报错接着往下看；
3，当我们使用子类实例化的时候，如果我们没有显式的使用super去调用父类中的构造函数，那么程序会自动的帮我们去调用父类中的无参构造函数进行初始化工作（此时如果出现上面那种情况，自己手写了有参构造但是没有写无参构造，那么程序不就出错了嘛！），再调用子类的有参/无参构造器。
4，为什么是调用父类的无参构造器而不是有参呢？回答是：不管子类的构造器有没有参数，因为子类继承的是父类的属性和方法，只调用父类的无参构造器就可以继承父类的属性和方法，因此不会调用父类的有参构造器。

JavaBean

JavaBean 是一种JAVA语言写成的可重用组件。为写成JavaBean，类必须是具体的和公共的，并且具有无参数的构造器。JavaBean 通过提供符合一致性设计模式的公共方法将内部域暴露成员属性，set和get方法获取。众所周知，属性名称符合这种模式，其他Java 类可以通过自省机制(反射机制)发现和操作这些JavaBean 的属性。
1，属性私有，无法主动修改，必须通过方法
2，set属性变量+get属性变量 首字母大写 具有这两种方法
3，无参数的构造器

多态概述

定义格式：父类类型 变量名=new 子类类型();当调用重写 的方法（同名同参数的方法），调用的是子类重写后的方法
不能调用父类没有的方法
上面两点总结：编译看左，运行看右（编译的时候只能变量.方法都是左边的，实际运行的是右边的方法）对象的多态性只适用于方法，不适用于属性，因为属性无法重写，因此调用的还是父类初始化的属性。运行时行为向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用类型转为子类引用各类型使用格式：子类类型 变量名=（子类类型） 父类类型的变量；
就是把类型强制转化为子类类型，就可以调用子类的属性和特有方法a instanceof A  判断对象a是否是类A的实例，返回true/false（如果你要强转，那也要转对，为true就可以直接向下转型了 ）实例子类时，付给父类变量，只是部分被屏蔽了，在向下进行转型时，又会出来。1.多态概述
多态是继封装、继承之后，面向对象的第三大特性。多态现实意义理解：现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。                                                                                                            Java作为面向对象的语言，同样可以描述一个事物的多种形态。如Student类继承了Person类，一个Student的对象便既是Student，又是Person。3.多态体现为父类引用变量可以指向子类对象。4.前提条件：必须有子父类关系。注意：在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法。5.多态的定义与使用格式                    6.理解:多态是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口，使用不同的实例而执行不同操作。2.多态中成员的特点
多态成员变量：编译运行看左边Fu f=new Zi();System.out.println(f.num);//f是Fu中的值，只能取到父中的值2.多态成员方法：编译看左边，运行看右边Fu f1=new Zi();System.out.println(f1.show());//f1的门面类型是Fu,但实际类型是Zi,所以调用的是重写后的方法。3.instanceof关键字作用：用来判断某个对象是否属于某种数据类型。注意： 返回类型为布尔类型使用案例：Fu f1=new Zi();Fu f2=new Son();if(f1 instanceof Zi){System.out.println("f1是Zi的类型");}else{System.out.println("f1是Son的类型");}
4.多态的转型  多态的转型分为向上转型和向下转型两种
向上转型：多态本身就是向上转型过的过程使用格式：父类类型 变量名=new 子类类型();适用场景：当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作。向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用类型转为子类引用各类型使用格式：子类类型 变量名=（子类类型） 父类类型的变量；适用场景：当要使用子类特有功能时。5.多态案例：
例1：（理解多态，可以重点看这个案例）package day0524;public class demo04 {public static void main(String[] args) {People p=new Stu();p.eat();//调用特有的方法Stu s=(Stu)p;s.study();//((Stu) p).study();}
}
class People{public void eat(){System.out.println("吃饭");}
}
class Stu extends People{@Overridepublic void eat(){System.out.println("吃水煮肉片");}public void study(){System.out.println("好好学习");}
}
class Teachers extends People{@Overridepublic void eat(){System.out.println("吃樱桃");}public void teach(){System.out.println("认真授课");}
}
例2：请问题目运行结果是什么？package day0524;
public class demo1 {public static void main(String[] args) {A a=new A();a.show();B b=new B();b.show();}
}
class A{public void show(){show2();}public void show2(){System.out.println("A");}
}
class B extends A{public void show2(){System.out.println("B");}
}
class C extends B{public void show(){super.show();}public void show2(){System.out.println("C");}
}答案：A B

可变参数

就是方法（int… a）{}；    … 就表示是可变的可变参数只能放参数的最后面，
编译时相当于一个int[]的数组，所以于方法名（参数相同，最后一个是可变参数，一个是数组）不能构成重载
可变参数可以直接传入参数，比如xF(1,2,3),但是如果参数是个数组就不行。

throws

定义一个方法的时候可以使用throws关键字声明。使用throws关键字声明的方法表示此方法不处理异常，而交给方法调用处进行处理。
throws关键字格式：
public 返回值类型 方法名称（参数列表，，，）throws 异常类{}；假设定义一个除法，对于除法操作可能出现异常，可能不会。所以对于这种方法最好将它使用throws关键字声明，一旦出现异常，
则应该交给调用处处理。
class Math{public int div(int i,int j) throws Exception{    // 定义除法操作，如果有异常，则交给被调用处处理int temp = i / j ;    // 计算，但是此处有可能出现异常return temp ;}
};
public class ThrowsDemo01{public static void main(String args[]){Math m = new Math() ;        // 实例化Math类对象try{System.out.println("除法操作：" + m.div(10,2)) ;}catch(Exception e){        // 处理异常e.printStackTrace() ;    // 就打印了异常内容}}
};

包装类

基本数据类型包括byte, short, int, long, float, double, char, boolean
对应的包装类分别是Byte, Short, Integer, Long, Float, Double, Character, Boolean。将基本数据类型转化为对应类型的包装类的过程叫“装箱”；将包装类转为对应类型的基本数据类型的过程叫“拆箱”包装类/基本数据转换成String：String a =String.valueof（object/int b）
String转换成包装类/基本数据类型：double x = Double.parseDouble（string）
都是静态方法哦通过valueof创建Integer对象时（不使用new，直接赋值），如果数值在【-128，127】之间，便返回指向IntegerCache.cache已经存在的对象引用，否则创建一个新对象

单例设计模式

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。并且该类只提供一个取得其对象实例的方法。如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为 private，这样，就不能用 new 操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。* 单例设计模式:* 1.所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例*  * 2.如何实现？*   饿汉式   VS  懒汉式* * 3.区分饿汉式和懒汉式。*       饿汉式：坏处:对象加载时间过长。*                好处:饿汉式是线程安全的。* *   懒汉式：好处:延迟对象的创建。*              坏处:目前的写法，会线程不安全。---》到多线程内容时，再修改1、单例模式的饿汉式
public class SingletonTest {public static void main(String[] args) {
//      Bank bank1 = new Bank();
//      Bank bank2 = new Bank(); Bank bank1 = Bank.getInstance();Bank bank2 = Bank.getInstance();System.out.println(bank1 == bank2);}
}//单例的饿汉式
class Bank{//1.私有化类的构造器private Bank(){}//2.内部创见类的对象//4.要求此对象也必须声明为静态的private static Bank instance = new Bank();//3.提供公共的静态的方法，返回类的对象。public static Bank getInstance(){return instance;}
}
2、单例模式的懒汉式
public class SingletonTest2 {public static void main(String[] args) {Order order1 = Order.getInstance();Order order2 = Order.getInstance();System.out.println(order1 == order2);}
}
class Order{//1.私有化类的构造器private Order(){}//2.声明当前类对象，没有初始化。//此对象也必须声明为 static 的private static Order instance = null;//3.声明 public、static 的返回当前类对象的方法public static Order getInstance(){if(instance == null){instance = new Order();           }return instance;}
}

代码块

** 类的成员之四:代码块（或初始化块）* * 1.代码块的作用：用来初始化类、对象的* 2.代码块如果有修饰的话，只能使用 static* 3.分类:静态代码块 vs 非静态代码块* * 4.静态代码块*  》内部可以有输出语句*  》随着类的加载而执行,而且只执行一次*  》作用:初始化类的信息*  》如果一个类中，定义了多个静态代码块，则按照声明的先后顺序执行*  》静态代码块的执行，优先于非静态代码块的执行*  》静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构* * 5.非静态代码块*  >内部可以有输出语句*  >随着对象的创建而执行（new，每创建一个对象就执行一次）*  >每创建一个对象，就执行一次非静态代码块。
*  >非静态代码块的执行优先于构造器*  >作用:可以在创建对象时，对对象的属性等进行初始化。*  >如果一个类中，定义了多个非静态代码块，则按照声明的先后顺序执行*  >非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法。*  * 对属性可以赋值的位置:*  ①默认初始化*  ②显式初始化*  ③构造器中初始化*  ④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值。*  ⑤在代码块中赋值*/
public class BlockTest {public static void main(String[] args) {String desc = Person.desc;System.out.println(desc);Person p1 = new Person();Person p2 = new Person();System.out.println(p1.age);Person.info();}
}class Person{//属性String name;int age;static String desc = "我是一个青年";//构造器public Person(){}//static 的代码块static{System.out.println("hello,static block-1");//调用静态结构desc = "我是一个爱小说的人";info();//不能调用非静态结构
//      eat();
//      name = "Tom";}static{System.out.println("hello,static block-2");}//非 static 的代码块{System.out.println("hello,block-2");}{System.out.println("hello,block-1");//调用非静态结构age = 1;eat();//调用静态结构desc = "我是一个爱小说的人 1";info();}    //方法public Person(String name,int age){this.name = name;this.age = age;}public void eat(){System.out.println("吃饭");}@Overridepublic String toString() {return "Person [name=" + name + ", age=" + age + "]";}public static void info(){System.out.println("我是一个快乐的人。");}}

final

/*

  • final:最终的
  • 1.final可以用来修饰的结构:类、方法、变量
  • 2.final用来修饰一个类:此类不能被其他类所继承。
  •    比如:String类、System类、StringBuffer类
  • 3.final修饰一个方法:final标记的方法不能被子类重写。
  •    比如：Object类中的getClass()。
  • 4.final用来修饰变量:此时的"变量"(成员变量或局部变量)就是一个常量。名称大写，且只能被赋值一次。
  • 4.1 final修饰属性，可以考虑赋值的位置有:显式初始化、代码块中初始化、构造器中初始化
  •    4.2 final修饰局部变量:

  •   尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。

  •  一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。
  • static final 用来修饰:全局常量
    */

抽象类与抽象方法/抽象类的匿名子类

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。/** abstract 关键字的使用* * 1.abstract:抽象的* 2.abstract 可以用来修饰的结构:类、方法* 3.abstract 修饰类:抽象类*  》 此类不能实例化*        》 抽象类中一定有构造器，便于子类实例化时调用(涉及:子类对象实例化全过程) （废话，类都有构造器）*        》 开发中，都会提供抽象类的子类，让子类对象实例化，实现相关的操作* * 4.abstract 修饰方法:抽象方法*  > 抽象方法，只有方法的声明，没有方法体。*  > 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法*  > 子类必须重写父类包含直接间接所有的抽象方案才能实例化，否则自己也只能是抽象类** abstract 使用上的注意点:* 1.abstract 不能用来修饰变量、代码块、构造器；* * 2.abstract 不能用来修饰私有方法、静态方法、final 的方法、final 的类。* */抽象类的匿名子类
就是创建一个一次性的类使用public class Num {}abstract class Creature{public abstract void breath();
}abstract class Person extends Creature{String name;int age;public Person(){}public Person(String name,int age){this.name = name;this.age = age;}//不是抽象方法
//  public void eat(){
//      System.out.println("人吃饭");
//  }//抽象方法public abstract void eat();public void walk(){System.out.println("人走路");}
}class Student extends Person{public Student(String name,int age){super(name,age);}public Student(){}public void eat(){System.out.println("学生应该多吃有营养的。");}@Overridepublic void breath() {System.out.println("学生应该呼吸新鲜的无雾霾空气");}
}
PersonTest 类/** 抽象类的匿名子类* */
public class PersonTest {public static void main(String[] args) {method(new Student()); //匿名对象Worker worker = new Worker(); method1(worker);   //非匿名的类非匿名的对象method1(new Worker()); //非匿名的类匿名的对象System.out.println("*********************");//创建了一个匿名子类的对象:pPerson p = new Person(){@Overridepublic void eat() {System.out.println("吃东西");}@Overridepublic void breath() {System.out.println("呼吸空气");}};method1(p);System.out.println("**********************"); //创建匿名子类的匿名对象method1(new Person(){@Overridepublic void eat() {System.out.println("吃零食");}@Overridepublic void breath() {System.out.println("云南的空气");}});}public static void method1(Person p){p.eat();p.walk();}public static void method(Student s){}
}
class Worker extends Person{@Overridepublic void eat() {}@Overridepublic void breath() {}
}public class AbstractTest {public static void main(String[] args) {//一旦 Person 类抽象了，就不可实例化
//      Person p1 = new Person();
//      p1.eat();}
}abstract class Creature{public abstract void breath();
}abstract class Person extends Creature{String name;int age;public Person(){}public Person(String name,int age){this.name = name;this.age = age;}//不是抽象方法
//  public void eat(){
//      System.out.println("人吃饭");
//  }//抽象方法public abstract void eat();public void walk(){System.out.println("人走路");}
}class Student extends Person{public Student(String name,int age){super(name,age);}public void eat(){System.out.println("学生应该多吃有营养的。");}@Overridepublic void breath() {System.out.println("学生应该呼吸新鲜的无雾霾空气");}
}

接口

内部類

异常

IDEA操作

多线程

【学习记录-java】Java基础学习笔记相关推荐

  1. java多线程基础学习[狂神说java-多线程笔记]

    java多线程基础学习 一.线程简介 1.类比 2.程序进程线程 3.线程的核心概念 二.线程的实现(重点) 调用方法与调用多线程的区别 Thread 类 1.thread使用方法 2. 代码实现 3 ...

  2. java基础案例教程前4章知识点_java学习记录4 Java基础知识点

    java学习记录4 Java基础知识点 1. 注释 单行注释 使用"//"开头,后面是注释的内容 一般在要注释的语句的上面加注释 多行注释 以"/*"开头,以& ...

  3. 【Java】Java零基础学习笔记

    文章目录 前言 思维导图 前期准备 卸载JDK 安装JDK Hello,world 可能遇到情况 java程序运行机制 IDEA的安装 java基础部分 基础语法 运算符 包机制 javaDoc文档手 ...

  4. Java零基础学习全套视频笔记

    Java零基础学习全套视频笔记 一.Java基础 1.注释 注释并不会被执行,是给我们写代码的人看的,防止项目结构代码太多忘记代码相关功能. 书写注释是一个非常好的习惯,平时写代码也一定要注意规范. ...

  5. Java零基础学习难吗

    java编程是入行互联网的小伙伴们大多数的选择,那么对于零基础的小伙伴来说Java零基础学习难吗?如果你是初学者,你可以很好的理解java编程语言.并不困难.如果你的学习能力比较高,那么你对Java的 ...

  6. 【J2ME 2D 游戏开发系列】◣HIMI游戏开发启蒙教程◢JAVA零基础学习J2ME游戏开发全过程!...

    本站文章均为 李华明Himi 原创,转载务必在明显处注明:  转载自[黑米GameDev街区] 原文链接: http://www.himigame.com/j2me-2/774.html Himi从写 ...

  7. Java零基础学习Java编程语言基础知…

    很多Java编程初学者在刚接触Java语言程序的时候,不知道该学习掌握哪些必要的基础知识.下面就说说Java零基础学习Java编程语言基础知识的几个要点.希望能够对Java编程基础入门学习的新手有帮助 ...

  8. java入门基础学习（三）

    文章目录 (一)有返回值的方法 (二)方法重载 习题 (一)有返回值的方法 格式:public static 返回值数据类型 方法名(参数){方法体return 数据;} 注意:1.返回值数据类型非v ...

  9. java编程基础学习需要多久的时间

    Java是当前世界颇为流行的编程语言之一,很多想学习java的人都会听过一句话,先学好java基础,在考虑是自学还是培训学习,同时新的问题出现了,java基础包括什么,需要学习多久呢,对于小白来说,想 ...

  10. IDL学习记录和Java调用IDL方法

    IDL学习记录和Java调用IDL方法 2018年02月06日 08:32:02 回首1949 阅读数:385更多 个人分类: 随想 版权声明:乐呵乐呵得了 https://blog.csdn.net ...

最新文章

  1. shell监控java接口服务_Linux系统下Java通过shell脚本监控重启服务
  2. 支持手机版网站的We7CMS
  3. 刚刚，谷歌终于回应AI专利争议：怕被碰瓷，抢先下手，永不牟利
  4. 标定板标定和九点标定的区别_射频导纳物位计的标定方法
  5. 关于J2EE中死锁问题的研究(2)
  6. 通过Rancher安装K8s
  7. PPT图片模板等素材打包下载
  8. MicroProfile变成了Eclipse MicroProfile
  9. 一、安装Windows 2012域控(For SQLServer 2014 AlwaysOn)
  10. 2015年网络安全专家信心开始动摇
  11. 【软件测试】使用C++ Test进行动态测试
  12. java无法双击打开.jar文件/jar包以压缩文件显示
  13. Black Hat USA 2011: Alexander Polyakov - CTO - ERPScan
  14. 谈谈Gameplay，以及UE4的Gameplay框架
  15. Java基础知识(七) 输入输出流
  16. Scrapy学习记录
  17. 京东2018校招研发笔试题记录
  18. 你见过的最差的程序员是怎样的？
  19. “加密上海·喜玛拉雅Web3.0数字艺术大展”落幕，AIGC和数字艺术衍生品是最大赢家？...
  20. 懂我的人不需要我解释,不懂我的人我不需要解释。。

热门文章

  1. 四川医生汪辉德“援非”两年救治患者1800余人
  2. android实现抖音列表,Android使用RecyclerView实现抖音主界面
  3. 像 Google、Facebook、微软这样的超级大公司招聘，会很看重学历吗？
  4. 【spider】爬虫（一个用requests方法抓取雪球网的关注人following的例子）
  5. 简易两位二进制乘法器设计
  6. Sqlsession 的理解
  7. 阿里云https证书tomcat配置
  8. 两万字讲全数据实时同步方案
  9. req.getAttribute 和 req.getParameter
  10. Android 圆角闪光遮照效果