面向对象
概念
什么是面向对象：
三大特性：封装、继承、多态。
static修饰符和final修饰符
static修饰符：
final修饰符：
-
修饰类:不能被继承。
-
修饰方法：不能被重写。
-
修饰变量：（都不可以二次赋值）常量。
局部变量：（局部变量没有默认值，不要求立刻赋值，只要用之前赋值就可以）
成员变量：（有默认值，但被final修饰后就没有默认值了，赋值不能晚于构造方法的执行）
方法的调用
在同一个类中：
对于静态方法，其他的静态或非静态方法都可以直接调用它。
而对于非静态方法，其他的非静态方法是可以直接调用它的。但是其他静态方法只有通过对象才能调用它。
在不同类中：
静态方法/非静态方法调用静态方法 类名.方法名 调用即可
静态方法/非静态方法调用非静态方法 实例化这个类 即new一个实例化对象 eg：
一个类只能有一个public class类，而class可以有多个。
值传递和引用传递
package com.atxins.idea.oop;
//值传递
public class Demo02 {
public static void main(String[] args) {
int a= 1;
System.out.println(a); //1
change(a);
System.out.println(a); //1
}
public static void change(int a){
a=10;
}
}
package com.atxins.idea.oop;
//引用传递：对象，本质还是值传递
public class Demo03 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name); //null
change(person);
System.out.println(person.name); //wangfei
}
public static void change(Person person){
//person是一个对象：指向的---->Person person = new Person();这是一个具体的人，可以改变属性！
person.name="wangfei";
}
}
//定义一个Person类，有一个属性：name
class Person{
String name; //null
}
构造器详解
注意：一个类即使什么都不写，它也会存在一个方法。
Demo示例：
构造器的作用是：1,2。
定义了有参构造之后，如果想使用无参构造，显示的定义一个无参构造。
创建对象的内存分析
对象是通过引用来操作的：栈—>堆
封装
记住这句话就够了：属性私有，get/set（有时会做一些安全性验证）
封装的意义：
- 提高的程序的安全性，保护数据。
- 隐藏代码的细节。
- 统一接口。
- 系统可维护行增加了。
继承
super详解
super()；注意点
- 默认调用父类的无参构造。
- 如果要显示调用父类的构造器，必须要在子类构造器的的第一行。
- super必须只能出现在子类的方法或构造方法中！
- super和this不能同时调用构造方法。
Vs this：
代表的对象不同：
this：本身调用者这个对象
super：代表父类对象的应用
前提：
this：没有继承也可以使用。
super：只能在继承条件下使用。
构造：
this（）；本类的构造；
super（）；父类的构造！
四种修饰符的具体区别
1、public：同一类下都可以直接进行调用
2、private：作用于当前类。
3、protected：作用于同一包下的子孙类。
4、default：作用同一包下的。
public>protected<default<private
即：类的成员不写访问修饰时默认为default。默认对于同一个包中的其他类相当于公开（public），对于不是同一个包中的其他类相当于私有（private）。
Java中，外部类的修饰符只能是public或默认，类的成员（包括内部类）的修饰符可以是以上四种。
方法的重写
方法重载和方法重写的区别
| 区别点 | 重载 | 重写（覆写） |
|---|---|---|
| 英文 | overloading | overriding |
| 定义 | 方法名称相同，参数的类型或个数不同，与返回类型无关；对权限没有要求 | 方法名称，参数类型，返回值类型全部相同（即子类的方法和父类必须一致；方法体不同。） |
| 范围 | 发生在一个类中 | 发生在继承类中 |
重写注意点：
- 修饰符：范围可以扩大但不能缩小
- 抛出的异常：范围，可以被缩小，但不能扩大。
- 为什么需要重写：父类的功能，子类不一定需要，或者不一定满足！
- 重写都是方法的重写，和属性无关。
- 重写只和非静态方法有关。
代码示例：
package com.atxins.idea.ChongXie;
// 父类
public class B {
public void test(){
System.out.println("B=>text");
}
}
package com.atxins.idea.ChongXie;
//子类
public class A extends B{
//Override 重写
@Override
public void test() {
System.out.println("A=>text");
}
}
package com.atxins.idea.ChongXie;
public class Test {
//非静态：重写
public static void main(String[] args) {
A a = new A();
a.test();
//父类的引用指向了子类
B b = new A();//子类重写了父类的方法
b.test();
}
}
结果：
多态
即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
多态注意事项：
-
多态是方法的多态，属性没有多态。
-
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。
-
父类和子类，有联系。 类型转化异常 ClassCastException!
-
存在条件：有继承关系、子类重写父类的方法、父类引用指向子类对象。 Father f1 = new son();
有些方法不能被重写：
- static 方法，属于类，它不属于示例。
- final 常亮
- private 方法。
示例Demo：
instanceof和类型转换
instanceof （类型转换）引用类型，可以判断两个类之间是否存在父子关系，有父子关系，true。否则，false。
类型转换：
- 父类引用指向子类对象
- 把子类转换为父类，向上转型；
- 把父类转换子类，向下转型；强制转换，可能丢失自己的本来的一些方法。
- 方便方法的调用，减少重复的代码，简洁。
静态代码块只执行一次。
抽象类
package com.atxins.idea.Demo01;
//abstract抽象类
public abstract class Action {
//约束~有人帮我们实现
//abstact,抽象方法，只有方法名，没有方法的实现。
public abstract void doSomething();
//1.不能new这个抽象类，只能靠子类去实现它；约束！
//2.抽象类中可以写普通的方法~
//3.抽象方法必须在抽象类中
//抽象的抽象：约束
}
package com.atxins.idea.Demo01;
//抽象类的所有方法，继承了它的子类，都必须要实现它的方法~ 除非子类也是抽象类
public class A extends Action {
@Override
public void doSomething() {
}
}
思考：抽象类中含有构造器吗？
抽象类可以有构造方法，只是不能直接创建抽象类的实例对象而已。在继承了抽象类的子类中通过super()或super(参数列表)调用抽象类中的构造方法。
如果你不能对抽象类实例化那么构造函数的作用是什么？好吧，他可以用来初始化抽象类内部声明的通用变量，并被各种实现使用。
接口
package com.atxins.idea.demo02;
public interface UserService {
//常量~public static final
int AGE=99;
//接口中的所有定义的方法其实都是抽象的 public abstract(默认有)
// 接口中方法的格式：返回值类型 方法名();
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
作用：
- 约束
- 定义一些方法，让不同的人实现
- 默认的方法：public abstract
- 默认的常量：public static final
- 接口不能被实例化，接口没有构造方法。
- implements可以实现多个接口
- 必需要重写接口中的方法
N中内部类
成员内部类：
静态内部类：
局部内部类：
package com.atxins.idea.demo03;
public class Outer {
//局部内部类（方法里）
public void method(){
class Inner{
public void in(){
System.out.println("good");
}
}
}
}
匿名内部类：
package com.atxins.idea;
public class Test {
public static void main(String[] args) {
//没有名字初始化类（即匿名内部类），不用将实例保存到变量中。
new Apple().eat();
//new 用来实现接口中方法
new UserService(){
@Override
public void hello() {
}
};
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
interface UserService{
void hello();
}
Error和Exception
异常的简单分类：
-
检查型异常 ：通常是用户错误或问题引起的
-
运行时异常：运行时异常可以在编译时被忽略
-
错误ERROR：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。
异常结构体系
java把异常当做对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类。
捕获和抛出异常
try-catch：
package com.atxins.idea.exception;
//手动添加
public class Test {
public static void main(String[] args) {
int a=0;
int b=0;
//假设要捕获多个异常：从小到大！
try { //try监控区域
System.out.println(a/b);
new Test().a();
}catch (ArithmeticException r){ //catch(想要捕获的异常类型！最高Throwable)捕获异常
System.out.println("程序出现异常，变量b不能为0");
}catch (Exception e) {
System.out.println("Exception");
}catch (Throwable t) {
System.out.println("Throwable");
} finally { //处理善后工作
System.out.println("finally");
}
//finally 可以不要finally，但一些IO、资源，关闭需在finally里进行
}
public void a(){
b();
}
public void b(){
a();
}
}
package com.atxins.idea.exception;
//自动添加
public class Test02 {
public static void main(String[] args) {
int a=0;
int b=0;
//Ctrl+Alt+t 选中要包裹的代码，快捷键自动生成
try {
System.out.println(a/b);
} catch (Exception e) {
e.printStackTrace(); //打印错误的栈信息
} finally {
}
}
}
throw、throws:
package com.atxins.idea.exception;
public class Test03 {
public static void main(String[] args) {
try {
new Test03().test(1,0);
} catch (ArithmeticException e) {
e.printStackTrace();
}
}
//假设这方法中，处理不了这个异常。可从方法上抛出异常-->throws,不在打印异常信息
public void test(int a,int b)throws ArithmeticException{
if(b==0){ //throw throws
throw new ArithmeticException();//主动抛出异常，一般在方法中使用
}
}
}
常见的一些异常：
算术异常类：ArithmeticExecption
空指针异常类：NullPointerException
类型强制转换异常：ClassCastException
数组负下标异常：NegativeArrayException
数组下标越界异常：ArrayIndexOutOfBoundsException
违背安全原则异常：SecturityException
文件已结束异常：EOFException
文件未找到异常：FileNotFoundException
字符串转换为数字异常：NumberFormatException
操作数据库异常：SQLException
输入输出异常：IOException
方法未找到异常：NoSuchMethodException
自定义异常
demo示例：
package com.atxins.idea.demo04;
//自定义的异常类
public class MyException extends Exception{
//传递数字>10;
private int detail;
public MyException(int a) {
this.detail=a;
}
//toString：异常的打印信息
@Override
public String toString() {
return "MyException{"+detail+"}";
}
}
package com.atxins.idea.demo04;
//测试类
public class Test {
//可能会在异常的方法
static void test (int a) throws MyException { //抛出去，让调用这个方法的来捕获它
System.out.println("传递的参数为："+a);
if(a>10){
throw new MyException(a);
}
System.out.println("Ok");
}
public static void main(String[] args) {
try {
test(11); //调用test方法，因为抛出了异常，所以要捕获它/或者继续抛出.
} catch (MyException e) {
System.out.println("MyException=>"+e); //处理异常，增加一些处理异常的代码块
//输出自己定义的消息e(不要简单的调用printStackTrace去打印输出)
}
}
}
try-catch和throw、throws的区别和联系
区别一：throw 是语句抛出一个异常；throws 是方法抛出一个异常；
throw语法：throw <异常对象>
在方法声明中，添加throws子句表示该方法将抛出异常。如果一个方法会有异常，但你并不想处理这个异常，就在方法名后面用throws,这样这个异常就会抛出，谁调用了这个方法谁就要处理这个异常，或者继续抛出.
throws语法：[<修饰符>]<返回值类型><方法名>（[<参数列表>]）[throws<异常类>]
其中：异常类可以声明多个，用逗号分割。
区别二：throw要么和try-catch-finally语句配套使用，要么与throws配套使用。但throws可以单独使用，然后再由处理异常的方法捕获。
联系一：try … catch 就是用catch 捕获 try 中的异常，并处理；catch是捕获异常。也就是说某一个操作有可能会抛出什么异常。throw 就是不处理异常，直接抛出异常
调用一个会throws exception的方法（在方法定义的时候可以用throws实现）时，需要把这个方法放在try里，然后用catch破获这个exception，做相应的处理。
throw new exception（）是抛出一个exception，由别的method来破获它。
也就是说try…catch是为破获别人的exception用的，而throw是自己抛出exception让别人去破获的。
实际应用中的一些总结:
使用try-catch捕获处理异常后，程序就不会停止了。try和catch只能获取程序运行时引发的异常，而throw语句可以引发明确的异常，程序到了throw语句这后就立即停止，不会执行后面的程序。
集合
集合的分类:
List
有顺序 可重复
Set
无序 不可重复
Map
键值对 key value 键的不可重复
示例Demo：
package com.atxins.idea.ListTest;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test001 {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
list.add(2,"ddd"); //往后顺移
list.set(2,"ddd"); //替换
list.remove(1);
list.remove("ccc");
//使用迭代器的方式遍历集合
Iterator<String> it = list.iterator();
while (it.hasNext()){
String temp = it.next(); //next()作用：1.取出当前值 2.将标记往后移，继续取出下一个值
System.out.println(temp);
}
}
}
Set：无序
HashSet：
无序
不可重复：通过hashCode和equals判断
TreeSet：
升序排序（按照值的自然顺序进行升序排序）：实现了SortedSet
不可重复：compareTo中的等于0来判断是否重复。
import java.util.HashSet;
import java.util.Set;
public class Test002 {
public static void main(String[] args) {
Set<String> set =new HashSet<String>();
set.add("aaa");
set.add("bbb");
set.add("ccc");
//set.remove("bbb");
for (String temp : set) {
System.out.println(temp);
}
}
}
//使用Set<E> set =new HashSet<E>();这种形式添加、删除数据（对象）判断重复不重复，与equals、hashCode两个方法都有关，需重写这两个方法。
//两个对象hashCode相等的时候，equals方法才会执行，进一步操作，如果hashCode不等，那么equals方法不执行，并且认为两个对象不等。
synchronized:不支持多线程访问。
Map:key-value key不可以重复，value可以重复
HashMap：无序，key不可以重复（hashCode和equals），key允许为空
TreeMap：按照key进行升序排序，key不可重复（与compareTo方法有关）
HashTable：与HashMap相近，区别在于HashTable中的方法基本都是同步方法，key不允许null，直接会抛出NullPointException
package com.atxins.idea.ListTest;
import com.atxins.idea.oop.Student;
import java.util.*;
public class Test003 {
public static void main(String[] args) {
//HashMap:无序，key不可重复,value可重复
Map<String,Integer> map = new HashMap<String, Integer>();
map.put("a",1000);
//key重复(hashcode、rquals)的时候，新的值会替换掉原来的值
map.put("b",2000);
map.put("c",3000);
map.put("d",4000);
// Integer c = map.get("c");
// System.out.println(c);
//键和值都存入set中
// Set<Map.Entry<String, Integer>> ss = map.entrySet();
// Iterator<Map.Entry<String, Integer>> it = ss.iterator();
// while (it.hasNext()){
// Map.Entry<String, Integer> en = it.next();
// System.out.println(en.getKey()+","+en.getValue());
// }
//将所有的key存入set
Set<String> keys = map.keySet();
for (String key : keys) {
System.out.println(key+","+map.get(key));
}
//TreeMap:按照key进行升序排序，key不可重复（与compareTo方法有关），新的值会替换掉原来的值
//如果key是自定义的类，那么该类型需要实现排序接口
Map<String,Integer> treeMap = new TreeMap<String, Integer>();
}
}
常用类
String：
常见方法：
charAt()
concat(String s）
contains(CharSequence s)
endsWith(String suffix)
indexOf()
length()
substring()
指定某一个分隔符，进行分割的方法：
package com.atxins.idea.string;
public class Test {
public static void main(String[] args) {
//String s1 ="zhangsan,lisi,wangwu,liliu";
String s2 ="1-2-3-4-5";
//指定某一个分隔符，进行分割的方法：
String[] sp = s2.split("-");
for (String s : sp) {
int i = Integer.parseInt(s);
System.out.println(i+100);
}
}
}
字符串截取：
/***
* http://www.flvcd.com/
* .--, .--,
* ( ( \.---./ ) )
* '.__/o o\__.'
* {= ^ =}
* > - <
* / \
* // \\
* //| . |\\
* "'\ /'"_.-~^`'-.
* \ _ /--' `
* ___)( )(___
* (((__) (__))) 高山仰止,景行行止.虽不能至,心向往之。
*/
扫一扫
1350
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
