访问控制修饰符
public
容许跨工程拜访的类
protected
容许同包类+子类拜访
default
(不写修饰符默认暗藏)同包类
private
只容许本类拜访
权限大小比拟
public > protected > default > private
this和super关键字
this
this代表本类对象的一个援用对象。
–构造函数中,this()必须放在第一行。
–当局部变量和成员变量同名时,用于辨别。
–构造方法之间相互调用
public class Test_This {
public static void main(String[] args) {
new Demo().test();//通过对象,来拜访类里的成员(成员变量和成员办法)
}
}
class Demo{
int count = 20 ;//成员变量
public void test() {
int count = 10;//局部变量
System.out.println(count);//10,变量的就近准则,会应用局部变量 的值
//想要应用 和 局部变量 同名的 成员变量count--this调用成员变量
//this示意的是本类的对象的援用--底层帮你new了一个本类对象--Demo this = new Demo();
System.out.println( this.count );//20,成员变量
}
}
public class Test_This2 {
public static void main(String[] args) {
new Demo2(1);
//输入:
//无参结构
//含参结构1
}
}
class Demo2{
public Demo2() {
System.out.println("无参结构");
}
public Demo2(int a) {
this();//在构造方法中,应用this关键字,必须是第一条语句
System.out.println("含参结构"+a);
}
}
super
super代表父类对象的一个援用对象
–通过super关键字能够应用父类的内容
–如果用super,必须呈现在调用地位的第一行
public class Test_Super {
public static void main(String[] args) {
new Zi3(); //父类无参结构
//子类无参结构
new Zi3("含参"); //父类无参结构
//子类含参结构
}
}
class Fu3{
//如果父类有含参结构,子类找不到无参结构,须要在子类中应用super去调用父类的含参结构
public Fu3(String name) {
System.out.println("父类含参结构");
}
}
class Zi3 extends Fu3{
public Zi3() {
//super();如果没有super,在此处暗藏了--子类的构造方法中都会暗藏着父类的无参结构
super("含参");
System.out.println("子类无参结构");
}
public Zi3(String name) {
//此处也暗藏了super();证实子类每一个结构都暗藏了父类无参结构
super("含参");
System.out.println("子类含参结构");
}
}
this和super比拟
1、 this代表本类对象的援用,super代表父类对象的援用。
2、 this用于辨别局部变量和成员变量
3、 super用于辨别本类变量和父类变量
4、 — this.成员变量 — this.成员办法() — this(参数)代表调用本类内容
5、 –super.成员变量–super.成员办法()–super(参数)代表调用父类内容
6、 this和super不能够同时呈现在同一个构造方法里,他们两个只有呈现都得放在第一行,同时呈现的话,到底第一行放谁呢。。
static和final关键字
static
static用于润饰成员(变量&办法),使其成为动态资源。
特点
1、 能够润饰成员变量,成员办法
2、 随着类的加载而加载,优先于对象加载
3、 只加载一次,就会始终存在,不再开拓新空间
4、 全局惟一,全局共享
5、 能够间接被类名调用
6、 动态只能调用动态,非动态能够随便调用
7、 static不能和this或者super共用,因为有static时可能还没有对象
public class Test_Static {
public static void main(String[] args) {
//2,动态资源优先于对象加载,因为是随着类的加载就曾经加载了
Student.coding();//null
//正在敲代码
System.out.println(Student.name);//null
Student s = new Student();
s.study();//10
//null
//null
//正在敲代码
//正在学习java
System.out.println(s.age);//10
//1,动态资源,多了一种拜访形式,除了能够用对象拜访,更提倡用类名间接调用
Student.coding();//null
//正在敲代码
System.out.println(Student.name);//null
//3,动态资源是共享资源,可能被多个对象共享
Student s1 = new Student();
s1.name="张三";
Student s2 = new Student();
System.out.println(s2.name);//张三
}
}
class Student{
//一般资源
int age = 10;
public void study() {
//6,非动态调用关系? -- 调用任意资源
System.out.println(age);
System.out.println(name);
coding();
System.out.println("正在学习java");
}
//动态资源
static String name ;
static public void coding() {
//4,动态资源里,不能应用this或者super关键字!
//this.study();
//super.
//5,动态调用关系? -- 只能调用动态,不能调用非动态的
System.out.println(name);
System.out.println("正在敲代码");
}
}
final
final示意最终,能够润饰类、成员变量、成员办法。
特点
1、 被final润饰的类,不能被继承
2、 被final润饰的办法,不能被重写
3、 被final润饰的变量是个常量,值不能被更改
4、 常量的定义模式: final 数据类型 常量名 = 值
public class Test_Final {
public static void main(String[] args) {
Zi d = new Zi();
d.speak();//Fu..speak()
System.out.println(d.name);//欢欢
d.test();//欢欢
}
}
class Fu{
//final class Fu{
//1,被final润饰的类,不能被继承
final String name="欢欢";
public final void speak(){
System.out.println("Fu..speak()");
}
}
class Zi extends Fu{
//public void speak(){ }
//2,被final润饰的办法,不能被重写
public void test(){
//super.name="大黄";
//3,被final的变量,不能从新被赋值
System.out.println(super.name);
}
}
异样
用来封装错误信息的对象(bug)。
组成构造:类型,提醒,行号。
Throwable
Throwable - 顶级父类
-Error:零碎谬误,无奈修复
-Exception:可修复的谬误
-RunTimeException
-ClassCastException
-ClassNotFoundException
Exception
程序中遇到了异样(Exception),通常有两种解决形式:捕捉或者向上抛出。
当调用了一个抛出异样的办法时,调用地位能够不做解决持续向上抛出也能够捕捉异样。
1.捕捉异样(应用try{}catch{})
try{
须要捕捉的代码
}catch(异样类型 异样名){
解决计划
}
测试
import java.util.InputMismatchException;
import java.util.Scanner;
//测试 异样
public class Test_Exception {
public static void main(String[] args){
method();//捕捉异样
}
/* 捕捉异样
* try{ 代码... }catch(异样类型 异样名){ 正当的解决方案 }
* 异样类型: ArithmeticException / InputMismatchException
*/
public static void method() {
try {
int a = new Scanner(System.in).nextInt();
int b = new Scanner(System.in).nextInt();
System.out.println(a/b);
}catch(InputMismatchException a) {
System.out.println("请输出两次整数!");
}catch(ArithmeticException a) {
System.out.println("第二次输出的整数不能为0 !");
}catch(Exception a) {
//怎么捕捉其余的所有异样呢?--多态--通用性强-不关怀子类类型,把子类当做父类来看
//所有Exception的子类都能被捕捉!
System.out.println("请输出正确的数据!!");
}
}
}
多组数据后果
0
0.1
请输出两次整数!
5
0
第二次输出的整数不能为0 !
2.抛出异样(办法上应用throws 异样类型)
main() throws InputMismatchException{}
测试
import java.util.Scanner;
public class Test_Exception2 {
public static void main(String[] args){
try {
//调用了抛出异样的method2(),须要解决,捕捉或者抛出二选一
method2();//抛出异样
}catch(Exception e) {
System.out.println("运算谬误!");
}
}
/* 抛出异样
* 在办法申明上加 throws 异样类型1,异样类型2...
*/
public static void method2() throws Exception{
int a = new Scanner(System.in).nextInt();
int b = new Scanner(System.in).nextInt();
System.out.println(a/b);
}
}
5
0
运算谬误!
代码块
被 { } 包起来的一段代码就叫代码块
结构代码块
特点
1、 在类的外部,办法内部,的代码块。
2、 通常用于抽取构造方法中的共性代码。
3、 每次调用构造方法前都会调用结构代码块
4、 优先于构造方法加载
部分代码块
特点
1、 在办法外面的代码块
2、 通常用于控制变量的作用范畴,出了括号就生效
3、 变量的范畴越小越好,成员变量会有线程平安问题
动态代码块
随着类的加载而加载,并且只被加载一次,个别用于我的项目的初始化
static{…}//在成员地位,领有static关键字的代码块
特点
1、 动态代码块:static{ },地位:在类里办法外
2、 在类加载时就执行,不论创立多少对象,只会执行一次的代码块
执行程序(代码块+构造方法+继承)
总体程序:
启动程序 -> 父类动态代码块 -> 子类动态代码块 -> 子类main办法 -> new SubClass( ) -> 父类结构代码块 -> 父类构造方法中部分代码块 -> 子类结构代码块 -> 子类构造方法中部分代码块
class Parent {
public static String p_StaticField = "父类-动态变量";
public String p_Field = "父类-变量";
protected int i = 1;
protected int j = 2;
static {
System.out.println( p_StaticField ); // 1.
System.out.println( "父类-动态代码块" ); //2.
}
{
System.out.println( p_Field ); // 7.
System.out.println( "父类-结构代码块" ); // 8.
}
public Parent()
{
System.out.println( "父类-部分代码块" ); // 9.
System.out.println( "i=" + i + ", j=" + j ); // 10.
j = 3;
}
}
public class SubClass extends Parent {
public static String s_StaticField = "子类-动态变量";
public String s_Field = "子类-变量";
static {
System.out.println( s_StaticField ); // 3.
System.out.println( "子类-动态代码块" ); // 4.
}
{
System.out.println( s_Field ); // 11.
System.out.println( "子类-结构代码块" ); // 12.
}
public SubClass()
{
System.out.println( "子类-部分代码块" ); // 13.
System.out.println( "i=" + i + ",j=" + j ); //14.
}
public static void main( String[] args )
{
System.out.println( "main办法开始" ); // 5.
new SubClass(); // 6.
}
}
执行后果:
父类-动态变量
父类-动态代码块
子类-动态变量
子类-动态代码块
main办法开始
父类-变量
父类-结构代码块
父类-部分代码块
i=1, j=2
子类-变量
子类-结构代码块
子类-部分代码块
i=1,j=3
抽象类和接口
抽象类
概念
Java中能够定义没有办法体的办法,该办法由其子类来具体的实现。该没有办法体的办法咱们称之为形象办法,含有形象办法的类咱们称之为抽象类。
特点
1、 通过java关键字abstract实现
2、 能够润饰办法或者类
3、 抽象类中能够没有形象办法(由子类去实现)
4、 如果类中有形象办法,那该类必须定义为一个抽象类
5、 子类继承了抽象类当前,要么还是一个抽象类,要么就把所有形象办法都重写
6、 多用于多态中
7、 抽象类不能够被实例化
import java.io.IOException;
import java.io.Reader;
//测试 抽象类
public class Test_Abstract {
public static void main(String[] args) {
//创立多态对象--父类援用 指向 子类对象
//Animal2 a = new Dog2();//8,抽象类不能被实例化
Animal2 a = new Cat2();
a.eat();//父类的办法申明,父类的办法体
a.sleep();//父类的办法申明,子类的办法体(重写了)
}
}
//1,为什么产生父类?--为了提取子类的共性,进步父类代码的复用性
//2,怎么优化父类?--程序设计--父类有没有能够省略的性能--办法体能够省略
//4,如果类里蕴含形象办法,那么,这个类就是一个抽象类
//5,应用abstract关键字形容形象
abstract class Animal2{
public void eat() {
System.out.println("Animal...eat()");
}
//3,如果有办法体,写了也要被批改,那就能够省略不提供--没有办法体的办法--形象办法
abstract public void sleep() ;
}
//6,子类继承抽象类后,就继承来了形象办法,是一个 形象的 子类
abstract class Dog2 extends Animal2 {
}
//7,子类继承抽象类后,子类能够重写 所有的 形象办法
class Cat2 extends Animal2 {
@Override//注解,作用是用来标记这个办法是一个重写办法
public void sleep() {
System.out.println("猫吃鱼");
}
}
class SubReader extends Reader{
//形象办法必须重写,否则就是一个抽象类
//一般办法不是必须重写,而是要改才重写
public void close() throws IOException{
System.out.println("close() ");
}
public int read(char cbuf[], int off, int len) throws IOException{
System.out.println("read() ");
return 0 ;
}
}
构造方法
1、 抽象类里有构造方法
2、 抽象类本人不能被实例化,依然会提供构造方法,用于帮忙子类初始化
3、 当创立子类对象时,会触发子类的构造方法,子类的构造方法里第一条默认就会有super()
4、 构造方法的执行程序: 父类的 –> 子类的
public class Test_Abstract2 {
public static void main(String[] args) {
//2,先执行父类的 构造方法 ,再执行本人的构造方法
Animal3 a = new Dog3();
}
}
//创立抽象类
abstract class Animal3{
//3,抽象类不能被实例化,为什么还要提供构造方法?--为了不便子类new
public Animal3() {
System.out.println("Animal3..无参结构");
}
}
class Dog3 extends Animal3{
public Dog3() {
super();//1,默认就存在,会被动找父类的无参结构
System.out.println("Dog3..无参结构");
}
}
成员变量和成员办法
1、 既能够有变量,也能够有常量。
2、 抽象类里,既能够有一般办法,有能够有形象办法。
3、 抽象类里能够都是一般办法,目标是不让外界实例化
测试成员变量
public class Test_Abstract3 {
public static void main(String[] args) {
System.out.println( new Demo2().age );//10
//new Demo2().name = "123" ;final的常量,值不能被批改
System.out.println( new Demo2().name );//Demo
}
}
abstract class Demo{
int age = 10 ;
final String name = "Demo";
}
class Demo2 extends Demo{
}
测试成员办法
public class Test_Abstract4 {
public static void main(String[] args) {
Demo3 d = new Demo5();//Demo3 Demo4都是抽象类不能new
d.save();//多态的目标是统一标准,所有向父类看齐
d.delete(10);
d.update("jack");
}
}
//1,抽象类是一个非凡的类,非凡在 类里能够有一般办法和 形象办法,怎么决定类里的办法到底设计成一般办法还是形象办法呢?--看办法体有没有必要提供
abstract class Demo3{
public void save() {
System.out.println("数据保留胜利!");
}
abstract public void delete(int id) ;
abstract public void update(String name) ;
}
//2,子类继承了抽象类,只重写了一部分形象办法,也就是还蕴含着形象办法,所以依然是一个抽象类
abstract class Demo4 extends Demo3{
public void delete(int id) {
System.out.println("delete().."+id);
}
}
class Demo5 extends Demo4{
public void update(String name) {
System.out.println("update().."+name);
}
}
接口
Java外面因为不容许多重继承,所以如果要实现多个类的性能,须要能够通过实现多个接口来实现。
Java接口和Java抽象类代表的就是形象类型,就是咱们须要提出的形象层的具体表现。OOP[面向对象]的编程,如果要进步程序的复用率,减少程序的可维护性,可扩展性,就必须是面向接口的编程,面向形象的编程,正确地应用接口、抽象类这些太有用的形象类型做为java构造档次上的顶层。
特点
1、 接口中都是形象办法
2、 通过interface关键字创立接口
3、 通过implements让子类来实现
4、 能够了解成,接口是一个非凡的抽象类
5、 接口冲破了java的单继承的局限性
6、 接口和类之间能够多实现,接口和接口之间能够多继承
7、 接口是对外裸露的规定,是一套开发标准
8、 接口进步了程序的性能扩大,升高了耦合性
public class Test_Interface {
public static void main(String[] args) {
//6,接口和抽象类一样,都不能够被实例化
Demo d = new DemoImpl();
//7,多态对象为了对立调用规范,以父类为准
d.save();
d.delete();
}
}
//1,通过interface关键字,定义接口
interface Demo{
//2,接口里全都是形象办法(jdk1.8后能够是default/static的一般办法)
abstract public void save() ;
abstract public void delete() ;
}
//3,实现类想要应用接口的性能,须要和接口产生实现关系(相似继承)
//5,实现类实现了接口,能够重写 所有 形象办法
class DemoImpl implements Demo{
@Override//注解
public void save() {
System.out.println("数据保留胜利!");
}
@Override//注解
public void delete() {
System.out.println("数据删除胜利!");
}
}
//4,实现类实现了接口,能够是一个形象的实现类
//abstract class DemoImpl implements Demo{}
接口的应用
构造方法
接口里是没有构造方法的。在创立实现类的对象时默认的super(),是调用的默认Object的无参结构。
成员变量
接口里没有成员变量,都是常量。所以,你定义一个变量没有写修饰符时,默认会加上public static final
成员办法
接口里的办法–都是形象办法(java1.8前);
能够有static或者default的一般办法(java1.8后)
public class Test_Interface2 {
public static void main(String[] args) {
//3,应用接口里的动态常量?
//Inter.age = 30 ;//是final的常量
System.out.println( Inter.age );//20,是static的资源
System.out.println( new InterImpl().age );//20
Inter in = new InterImpl();
in.show();//这是jdk1.8的新个性
in.save();//数据保留胜利!
Inter.test();//这是jdk1.8的新个性--通过类名间接拜访接口里的一般的静态方法
}
}
interface Inter{
//1,接口里有没有构造方法?--没有--实现类到底怎么new的?--
//2,接口里有没有变量?--没有!!是static的final的常量public的
//public static final int age = 20 ;//接口会为你的变量,主动拼接public static final
int age = 20 ;//简写模式
//4,接口里有没有一般办法?--有,只不过是jdk1.8才提供的,必须润饰成default/static
default public void show() {
System.out.println("这是jdk1.8的新个性");
}
static public void test() {
System.out.println("这是jdk1.8的新个性");
}
//5,接口里有没有形象办法?--有
//abstract public void save() ;//接口会为你的形象办法,主动拼接public abstract
void save() ;//简写模式
}
//6,实现类实现接口后,对于一般办法必须重写吗?--不是,要改才重写
//7,实现类实现接口后,对于形象办法必须重写吗?--是,否则就是一个形象的实现类
class InterImpl extends Object implements Inter{
public InterImpl() {
//不是接口里的构造方法,因为接口基本没有构造方法,其实找的是Object的构造方法
super();
}
@Override
public void save() {
System.out.println("数据保留胜利!");
}
}
接口简单用法
1、 接口之间能够多继承,多个接口之间逗号隔开(突破了java单继承的局限性,)
2、 接口还能够多实现,只不过接口之间逗号隔开
3、 接口甚至还能够单继承的同时多实现
import java.io.Reader;
public class Test_Interface3 {
public static void main(String[] args) {
//2,左侧写的接口到底是谁?--要看你想用哪个接口的性能,左侧就写谁
Inter2 in = new Inter2Impl() ;
in.save();//数据保留胜利!
int rows = in.update(2) ;//数据曾经更新
System.out.println(rows);//5
System.out.println( in.update(2) );//数据曾经更新
//5
in.delete("jack");//删除记录胜利!jack
}
}
interface Inter1{
void save();
int update(int id);
}
interface Inter3{
void delete(String name);
}
//1,接口间是继承关系,而且能够多继承
interface Inter2 extends Inter1 , Inter3{
}
//4,实现类和接口,是实现关系,还能够多实现
class Inter3Impl implements Inter3 , Inter1 {
public void delete(String name) {
System.out.println("删除胜利!");
}
public void save() {
System.out.println("保留胜利!");
}
public int update(int id) {
System.out.println("更新胜利!");
return 5;
}
}
//5,实现类能够在单根继承的同时,多实现
//Inter4Impl须要重写Inter1和Inter3里的 所有形象办法,否则就是一个抽象类
abstract class Inter4Impl extends Object implements Inter1 , Inter3{
}
//3,实现类,实现了接口.须要把接口里 所有形象办法都重写.
//Inter2接口里的3个办法都要重写
class Inter2Impl implements Inter2{
@Override
public void delete(String name) {
System.out.println("删除记录胜利!"+name);
}
@Override
public void save() {
System.out.println("数据保留胜利!");
}
@Override
public int update(int id) {
System.out.println("数据曾经更新");
return 5;
}
}
抽象类和接口的区别
相同点
1、 都能够呈现形象办法
2、 都不能被实例化
3、 都须要子类重写形象办法
4、 接口和抽象类体现了继承构造里的形象层
不同点
1、 抽象类里有构造方法,用来给子类创建对象.接口里没有构造方法.
2、 抽象类里有变量,然而接口里,只有常量,会为简写的常量主动拼接public static final
3、 抽象类里有一般办法,然而接口里,都是形象办法(除了jdk1.8)
4、 接口里的形象能够简写,会为简写的形象办法主动拼接public abstract
5、 抽象类只能是和子类之间产生单根继承关系
6、 接口和实现类之间是实现关系,而且能够多实现
7、 接口和接口之间是继承关系,而且能够多继承
8、 接口是为了冲破java单继承的局限性来的