标签：java 构造方法 int 子类 基础知识 new 父类 方法
强制转换
由高转低需要强制转化，低到高自动转换byte short chat int long float double
int i=128;
byte b=(byte)i;
1、不能把布尔类型转换2、不能把对象转换成不相干的类型3、转换的时候可能会出现内存溢出精度问题
int money=10_0000_0000;
int year=20;
int total=money*year;//结果溢出了int的范围
long total1=monry*((long)year);//先把一个数转化为long类型
变量
public class Demo{
//实例变量不自行初始化默认为0或者0.0 布尔值默认为false 除了基本类型其他都为null
String name;//实例变量，从属于对象
static double a=1200;//类变量，前边加个static
//main方法
public static void main(String[] args){
int i=10;//局部变量，其他方法中不能使用，只在该{}有用
//变量类型 变量名字
Demo demo1=new Demo();
System.out.println(demo1.name);//输出实例变量
System.out.println(a);//使用类变量
}
//其他方法
public void add(){
}
}
常量
static final float PI=3.14 //使用final定义常量，固定值，之后可以直接引用
运算符
int a=3; int a=3;
int b=a++; //相当于 int b=a;
int a=a+1;
int a=1; int a=1;
int b=++a; //相当于 int a=a+1;
int b=a;
连接符
int a=1;
int b=2;
System.out.println(""+a+b)//结果为12
System.out.println(a+b+"")//结果为3
三元运算符
x ? y : z 如果x为真则返回y，如果为假，则返回z
文档注释
//使用/**加回车进行文档注释
/**
* @author tao 作者名
* @version 1.0 版本号
* @since 1.8 指明需要最早使用的jdk版本
*/
public class Doc {
String name;
/**
*
* @param name 参数名
* @return 返回值情况
* @throws Exception 抛出异常
*/
public String test(String name) throws Exception{
return name;
}
}
用户交互Scanner
通过Scanner类来获取用户的输入
语法：Scanner s=new Scanner (System.in);
next():
1、一定要读取到有效字符后才结束输入
2、对输入有效字符之前遇到的空白，next方法会自动将其去掉
3、只有输入有效字符后才将其后面输入的空白作为分隔符或结束符
4、next（）不能得到带有空格的字符串
nextLine()：
1、以Enter为结束符，可以获得空白
switch
每个case语句中都需要一个break,不然就会输出下面全部的case值
支持使用字符串对比
print和println的区别
print输出不会换行 println输出会换行
break和continue
break用于强行跳出循环，不执行循环语句剩余的语句
continue用户终止某次循环，跳过本次循环继续执行下一次循环的判断
方法
1、方法包含一个方法头和一个方法体
修饰符 返回值类型 方法名（参数类型 参数名）{
方法体
return 返回值；
}
形式参数：用于来定义方法内的参数
实际参数：实际调用给它的参数
方法的重载
1、名字一摸一样但是参数不同(可以个数不同、类型不同、参数排列顺序不同)
2、方法的返回类型可以相同也可以不同
3、只有返回类型不同不是方法的重载
可变参数
在方法声明中在指定参数类型后加一个省略号
一个方法中只能指定一个可变参数，必须是方法的最后一个参数，任何普通的参数必须在它之前声明
递归
边界条件 前阶段 返回阶段n*n-1
数组
必须声明数组变量
int[] num;
使用new操作符来创建数组
int[] num=new int[10];
获取数组长度
num.length
数组的四个特点：
①、其长度是确定的。数组一旦被创建，它的大小就是不可以改变的
②、元素必须是相同的类型，不允许出现混合类型
③、数组中的元素可以是任何数据类型，包括基本类型和引用类型
④、数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
数组本身就是对象，java中对象是在堆中的，因此无论保存原始类型还是其他对象类型。数组本身是在堆中的。(new出来的都是在堆)
数组的边界
下标的合法区间：[0，length-1]
ArrayIndexOutOfBoundsException：数组下标越界异常
##
增强的数组循环
int[] arrays={1,2,3,4}
//适合打印输出,没有下标
for(int array:arrays){
System.out.printl(array);
}
java内存分析
java内存分为堆、栈、和方法区
①、堆：存放new的对象和数组；可以被所有的线程共享，不会存放别的对象引用
②、栈：存放基本变量类型（包含这个基本类型的具体数值）；引用对象的变量（会存放这个在堆里面的具体地址）
③、方法区：可以被所有线程共享；包含了所有的calss和static变量
Arrays类
Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用
具有以下功能：
1、给数组赋值：使用.fill方法
2、对数组排序：通过sort方法，升序排序
3、比较数组：通过equals方法比较数组中元素是否相等
4、查找数组元素：通过binarySearch方法对排序号的数组进行二分查找
冒泡排序
比较数组中两个相邻的元素如果第一个比第二个数大，交换他们的位置，每次比较都会产生一个最大一个最小，下一轮则少一次排序
每一轮都能产生一个最大或者最小的数放在最后面或者最前面，然后继续从第一个开始比较
面向对象OOP
思想：分类得思维，思考问题首先会解决问题需要那些分类，然后对这些分类进行单独思考。
使用new关键字创建得时候，除了分配内存空间外，还会给创建好得对象进行默认得初始化以及对类中构造器得调用
本质：以类得方式组织代码，以对象得方式封装数据
三大特性
封装：
程序设计要求”高内聚，低耦合“内聚指类的内部数据操作细节自己完成，不允许外部干涉，耦合是指暴露少量方法给外部使用
（数据的隐藏）禁止直接访问一个对象中数据的实际标识，而应该通过操作接口来访问属性私有(private)，get/set
1、提高程序的安全性，保护数据
2、隐藏代码的实现细节
3、统一接口
4、系统可维护性增加
继承：
本质是对类的抽象，extend意思为子类是父类的扩展，在JAVA中只有单继承没有多继承（一个爸爸可有多个儿子）
继承是类和类之间的一种关系。继承关系的两个类一个为子类一个为父类，子类使用extend标识继承父类
所有的类都默认继承object类
多态：
同一方法可以根据发送对象不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
存在条件：①、有继承关系
②、子类重写父类方法
③、父类引用指向子类对象
注意事项： 1、多态是方法的多态，属性没有多态
2、父类和子类有联系（存在父子关系）不可以将一个类型转化为另一个类型（ClassCastException）
3、存在条件：继承关系，方法需要重写，父类引用指向子类对象Father f1=new Son()
不能重写(无多态) ①、static方法属于类不属于实例，不能被重写
②、final常量不能被重写
③、private方法不能被重写
对象，是具体得事物，类，是抽象得，是对对象得抽象
构造方法
类中的构造器（构造方法）实在进行创建对象时候必须要调用得
①、构造方法和类的名字相同
②、必须没有返回类型也不能写void
作用：
①、new本质在调用构造方法
②、初始化对象的值
注意点：
使用new本质是在调用构造方法，定义有参一定要显示无参构造，super调用父类的构造方法必须在子类构造方法第一行
alt+insert自动将有参无参构造方法补齐
super和this
super注意点
①、super调用父类的构造方法，必须在构造方法的第一个
②、super必须只能出现在子类的方法或者构造方法中
③、super和this不能同时调用构造方法（因为都必须保证他们在第一行）
与this对比
①、代表的对象不同
this:本身调用者这个对象
super:代表父类对象
②、前提：
this:没有继承也可以使用
super：只能在继承条件才可以使用
③、构造方法
this():该类的构造
super():父类的构造
方法的重写
需要有继承关系
子类重写父类的方法，方法一致但是方法体不同
①、方法名必须相同
②、参数列表必须相同
③、修饰符：范围可以扩大，父类private子类可以编程public(反过来不行)
④、抛出的异常：范围可以被缩小，但不能扩大：ClassNotFoundException(小)-->Exception(大)
为什么需要重写：父类的功能，子类不一定需要或者不一定满足
instanceof
根据父子类关系判断是否属于父子
先判断是否是继承关系，不是的话直接报错，是的话继续判断是否为父子
类的大小顺序：
Object>String
Object>Person>teacher
Object>Person>student
类型强制转化
//例如父类Person要使用Student子类独有的方法go()
高 -------------->低
Person person=new Student();
//这里不能使用person.go();因为go为子类独有的方法
//类型强制转化
((Student) person).go();
//子类转化为父类,可能丢失自己的本来的一些方法（大空间赋值给小空间，子类大空间中独有的方法会丢失）
Student student=new Student();
student.go();
低------------->高
Person person=student;//父类的引用指向子类的对象
①、父类的引用指向子类的对象
②、子类转换为父类（向上转型），不用强制转化，丢失子类独有方法
③、父类转化为子类（向下转型），需要强制转化
④、方便方法的调用，较少重复的代码
static
静态属性可以直接使用类名调用,静态就是属于该类，随着类加载就存在，static方法只执行一次，后面不执行
Public class Student{
private static int age;
private String name;
public void run(){
//非静态可以直接调用静态，静态不能直接调用非静态
go();
}
public static void go(){
}
public static void main(String[] args){
Student s1=new Student();
System.out.println(Student.age);
System.out.println(s1.age);
s1.run();
Student.go;//或者直接go();因为再类里面
}
}
public class Person{
static{
System.out.println("静态代码")
}
{
System.out.println("匿名代码")
}
public Person(){
System.out.println("构造方法")
}
public static void main(String[] args){
Person s1=new Person();//输出顺序：①、静态代码②、匿名代码③、构造方法
Person s2=new Person();//只输出：②、匿名代码③、构造方法
}
}
抽象类
子类必须重写这个父类抽象类的所有抽象方法，不然会报错，抽象类的所有抽象方法都必须由继承它的子类实现，除非子类也是抽象类 则由子子类实现。（抽象类相当于房子的图纸，设计好了让子类去实现）
注意点：
①、不能new这个抽象类，只能靠子类去实现它，只能去new他的一些子类对象
②、抽象类中可以有普通方法，抽象方法必须在抽象类中：约束作用
接口interface
接口就是规范，定义的是一组规则，体现现实中你是车，就必须能跑类似的规则
接口的本质是契约，就像法律，制定好后必须遵守
对比
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有，使用abstract定义，利用extends继承
接口：只有规范，自己无法写方法，使用interface定义，使用implement继承
⭐注意点：
①、接口中定义的所有方法都需要被子类重写实现，定义一些方法让不同的人去实现
②、接口中的所有方法定义其实都是抽象的public abstract
③、接口里面定义的属性都是常量public static final
④、接口不能被实例化，接口中没有构造方法
⑤、implement可以实现多个接口
异常机制
异常指程序运行中出现的不期而至的各种状况：文件找不到、网络链接失败、非法参数等。
java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类
分类
①、检查性异常：最具代表性的检查性异常是用户错误或问题引起的异常，程序员无法预见的
②、运行时异常：运行时异常时可能被程序员避免的异常。以检查性异常相反，运行时异常可以在编译时被忽略
③、错误ERROR：错误不是异常，而是脱离程序员控制的问题，错误在代码中通常被忽略
ERROR
ERROR类对象由java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。
java虚拟机运行错误，当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。异常发生时JVM一般会选择线程终止
还有发生再虚拟机试图执行应用时，如：类定义错误、链接错误。这些错误时不可查的，因为他们再应用程序控制和处理能力之外不允许出现的错误。
Exception
Exception中有一个重要子类RuntimeException（运行时异常）
ArrayIndexOutOfBoundsException（数组下标越界）
NullPointerException（空指针异常）
ArithmeticException（算术异常）
MissingResourceException（丢失资源）
ClassNotFoundException（找不到类）
异常处理机制
抛出异常 捕获异常
异常处理关键字：try catch finally throw throws
自定义异常
使用Java内置的异常类可以描述再编程时出现的大部分异常情况，用户可以自定义异常，只需要继承Exception类即可
步骤：①、创建自定义异常类
②、再方法中通过throw关键字抛出异常
③、如果在当前抛出异常的方法中处理异常，可使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛 出给方法调用者的异常。
④、在出现异常方法的调用者中捕获并处理异常
标签：java,构造方法,int,子类,基础知识,new,父类,方法 来源： https://www.cnblogs.com/tao-study/p/16538929.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。