java三大特性及其具体含义,java四大基本特性
如何解决写爬虫IP受阻的问题？立即使用。
相关：《Java视频教程》
Java的三大特性是Java的独特表现。当我们提到Java的三个特性时，我们都会想到封装、继承和多态，这是我们Java最重要的特性。
封装(Encapsulation) ：
封装：是指隐藏对象的属性和实现细节，只向外界提供公共访问。
好处：
隔离变更。
好用。
提高可重用性。
提高安全性。
包装原则：
隐藏所有不需要向外界提供的内容。
隐藏所有属性，并提供访问它们的公共方法。
私有关键字：
是权限修饰符。
用于修改成员(成员变量和成员函数)
私有化成员仅在此类别中有效。
一个常用的：
私有化成员变量，并提供相应的set和get方法来访问它们。提高数据访问的安全性。
举个栗子：
我们常说失血模型
公开课演示{
私有字符串名称；
私弦性；
私人年龄；
公共字符串getName() {
返回名称；
}
public void setName(字符串名){
this.name=name
}
公共字符串getSex() {
回报性；
}
public void setSex(String sex) {
this.sex=sex
}
public int getAge() {
回归年龄；
}
公共无效存储(整数){
this.age=年龄；
}
} 构造代码块和构造方法（Construct）：
构造方法：
用来初始化一个对象，它初始化相应的对象。它是有针对性的，也是功能之一。
特点：
该函数的名称与其所在的类名相同。不需要定义返回值类型。这个函数没有特定的返回值。构造函数不是我们手动调用的(手动调用指的是比如B1 . baby()；)，但是在创建相应的对象时，JVM会主动调用相应的构造函数。如果一个类没有显式地写构造函数，Java编译器会给这个类添加一个无参数的构造函数。如果一个类已经显式地编写了一个构造函数，Java编译器将不会向该类添加一个无参数的构造函数。构造函数可以以函数重载的形式在一个类中有多个函数。方法有参数化构造法和参数化构造法。默认情况下，无参数构造方法JVM创建一个。如果手动创建参数构造方法，默认情况下，系统会识别该参数构造方法。构造函数的定义格式：
修饰符函数名(形参){
功能体；
}
修饰符函数名(){
功能体；}构造方法与普通方法的区别：
(1)返回值类型的差异：
构造函数没有返回值类型。如果加上void或者其他返回值类型，就变成了普通函数，需要我们手动调用。
普通函数有返回值类型。即使函数没有返回值，返回值类型也要写成void。
(2)函数名的不同：
构造函数的函数名必须与类名一致。
普通函数的函数名可以满足标识符的命名规则。
(3)调用方法的差异：
JVM在创建对象时调用构造函数。
使用对象调用普通函数，一个对象可以多次调用普通函数。
(4)功能上的差异：
构造函数的作用是初始化一个对象。创建的每个对象都有一个初始值。
普通函数用于描述一类事物的公共行为。
注意事项：
(1)1)Java编译器添加的无参数构造方法的权限修饰符与类的权限修饰符一致。
(2)创建对象时调用构造函数，所以可以将属性值传递给构造函数，并在构造函数中设置参数来接收属性值。
(3)JVM和Java编译器不同。的。Java编译器生成的类文件是针对JVM的，所以编译后的类打开时会出现乱码，我们可以通过反编译来检查。
构造代码块：
1.构造代码块和构造函数的功能比较：
(1)构造代码块的功能：统一初始化所有对象，对象一建立就运行，优先于构造函数。比如，所有的婴儿出生时都会哭。
(2)构造函数的作用：初始化对应的对象（new ）。
构建代码块的格式：
{
构造一个代码块；
}
注意：构造代码块的花括号必须在成员的位置。代码类别：
(1)积木码：工作中经常用到。
(2)局部代码块：花括号位于方法内部，基本上写不写都没什么区别，真正的开发中很少用到。它的作用是缩短局部变量的生命周期，节省一点内存。
(3)静态代码块：用静态修饰的代码块。
注意的事项：
(1)编译Java源文件时，Java编译器会将成员变量的声明语句提前到类的前面。
(2)成员变量的初始化实际上是在构造函数中进行的。
(3)一旦被Java编译器编译，构造代码块的代码就会被移到构造函数中执行。构造代码块的代码在构造函数之前执行，构造函数中的代码最后执行。
(4)成员变量的显示初始化和构造代码块的代码按当前代码的顺序执行。
继承(inheritance)：
继承是面向对象最显著的特征。继承是从现有类派生出一个新类。新类可以吸收现有类的数据属性和行为，并扩展新的功能。
在JAVA中，继承的类称为父类或超类，继承父类的类称为子类或派生类。因此，子类是父类的特殊用途版本，它继承了父类中定义的所有实例变量和方法，并添加了唯一的元素。
继承的结构：
继承的使用：
关键词：扩展。
使用继承
编写父类
编写子类并继承父类
动物类{
//公共属性和方法
}
级鸡展动物{
//特定于子类的属性和方法
}
类鸭伸展动物{
}基本语法：
类Chicken扩展Animal{}上面的代码表示Chicken类继承Animal类，用extends关键字连接Animal类(父类/超类)和Chicken类(子类)；
在继承关系下，鸡类将拥有动物类的所有非私有方法和属性，鸡类也可以拥有自己独特的方法和属性；
声明动物类，当鸡类被实例化时，鸡类会自动转化为动物类；
举个栗子：
//创建一个动物类
公共类动物{
私有字符串类型；
私串皮肤；
private int legCount
public void eat(){
System.out.println(动物在吃)；
}
公共虚空气息(){
System.out.println(动物在呼吸)；
}
公共字符串getType() {
返回类型；
}
公共void setType(字符串类型){
this.type=type
}
公共字符串getSkin() {
还皮肤；
}
public void setSkin(字符串皮肤){
this.skin=皮肤；
}
public int getLegCount() {
返回legCount
}
public void setLegCount(int legCount){
this . leg count=leg count；
}
}
//鸡肉
公共课鸡展动物{
public void eat(){
System.out.println("小鸡在吃")；
}
公共无效运行(){
System.out.println("小鸡在跑")；
}
}
//鸭子
公开课鸭展动物{
public void eat(){
System.out.println("鸭子在吃")；
}
公共无效运行(){
System.out.println("鸭子在跑")；
}
}
//测试类
公共类测试{
公共静态void main(String[] args){
小鸡鸡=新鸡()；
chick . eat()；
Chicken.setType("小鸡")；
chicken . setskin(" golden ")；
chicken . setlegcount(2)；
System.out.println(动物种类为： chicken.getType()，皮肤颜色为： chicken.getSkin()，腿数为 t . getlegcount()))；
chick . run()；
鸭鸭=新鸭()；
duck . eat()；
duck . fight()；
}
}继承执行顺序：
在java中，new是一个类的对象，包括静态代码块、非静态代码块、无参数构造方法、参数构造方法、类的通用方法等等。它们的执行顺序相对简单，例如：
公共类父测试{
私有字符串名称；
public FatherTest(){
system . out . println("-父类的无参数构造方法-")；
}
public FatherTest(字符串名称){
system . out . println("-父类的参数化构造函数-" this . name ")；
}
静态{
system . out . println("-父类的静态代码块-")；
}
{
system . out . println("-父类的非静态代码块-")；
}
public void speak(){
system . out . println("-父类的方法-")；
}
}
公共静态void main(String[] args){
system . out . println("-父类主程序-")；
FattestFather=New FatherTest("父亲的名字")；
father . speak()；
}
执行结果是：
-父类的静态代码块-
-父类主程序-
-父类的非静态代码块-
-父类的参数化构造函数-父类的名字。
-父类的方法-
执行序列摘要：
静态代码块-主程序-非静态代码块-构造函数-添加子类继承后一般方法的执行顺序，例如：
公共类SonTest扩展了FatherTest{
私有字符串名称；
静态{
System.out.println( -子类的静态代码块-)；}
{
System.out.println( -子类的非静态代码块-)；
}
public SonTest(){
System.out.println( -子类的无参数构造函数-)；
}
公共SonTest(字符串名称){
System.out.println( -子类的参数化构造函数- name)；
}
@覆盖
public speak(){ system . out . println(-子类覆盖父类的方法-)；}
}
公共静态void main(String[] args) {
System.out.println( -子类主程序-)；
FatherTest father=new FatherTest(父亲的名字)；
father . speak()；
SonTest son=new SonTest(儿子的名字)；
son . speak()；
}
执行结果是：
-父类的静态代码块-
-子类的静态代码块-
-子类主程序-
-父类的非静态代码块-
-父类的参数化构造函数-父类的名字。
-父类的方法-
-父类的非静态代码块-
-父类的无参数构造函数-
-子类的非静态代码块-
-子类的参数化构造方法-子的名称
-子类覆盖父类的方法-方法覆盖：
方法重写是指在继承关系下，子类具有与父类相同的方法名、参数(个数、顺序、类型)和返回值类型，访问修饰符只能放大或相等，不能缩小，但实现过程与父类不同。方法重写也是多态的一种实现形式。
重写必须满足以下条件：在子类中，继承自基类的方法可以根据需要被重写；被重写的方法和被重写的方法必须具有相同的方法名；参数列表和返回类型；被重写的方法不能使用比被重写的方法更严格的访问权限；
举个栗子：
//鸡肉
级鸡展动物{
public void eat(){
System.out.println("小鸡在吃")；//在父类Animal中输入eat方法
行重写
}
公共无效运行(){
System.out.println("小鸡在跑")；//您可以添加一个新方法
}
}Super关键字：
super关键字是一个特殊的变量，它为父类提供了一个方法。可以使用super主动调用父类的构造函数，访问父类中的成员。
超级调用父类的构造方法：
公开课鸭展动物{
公共鸭(字符串名){
超级(名)；//主动调用父类的构造函数
}
}超级访问父类的成员：
在子类方法中，super用于访问父类中的隐藏成员。存取形式为：超级。可变；超级棒。方法名(参数)；
公开课鸭展动物{
@覆盖
public void eat() {
system . out . println()；
}
公共void庸医(){
system . out . println(super . name)；//使用super调用父类的属性
吃()；
super . eat()；//使用super调用父类的eat()方法
}
公共静态void main(String[] args) {
新鸭()。嘎嘎()；//创建一个Duck类对象并调用嘎嘎方法
}
}final 关键字：
关键字“final”用于修改类、方法和变量，意思是“不可变的、最终的”。
装饰声明为final的类不能被子类化，也就是说这个类不能被继承；
公共最终类人员{ }
修改一个变量，意味着它是一个常量，变量一旦初始化，就不能更改；
最终int COUNT=5；
修改方法向编译器表明子类不能重写该方法；
Public void eat () {}:
多态(polymorphism)
在面向对象语言中，多态性是指一个方法可以有多个实现版本，即“一个定义，多个实现”。只要新的类也在继承层次中，多态就可以用来设计和实现可伸缩的系统。新的类需要对程序的公共部分进行很少或不需要修改。类多态性用方法多态性来表示，方法多态性主要包括方法重载和方法覆盖。
过载：
方法重载意味着同一类中的多个方法可以有相同的名称，但参数列表必须不同。重载显示了同一类中方法的多态性。
鸡类{
public void eat(){
System.out.println("小鸡在吃")；
}
公共空吃(串食){
System.out.println("小鸡在吃食物)；//重载eat方法
}
}方法覆盖是指子类在父类中定义了一个同名的方法。Override显示了父方法、子方法和子类方法之间的多态性。
//鸡肉
级鸡展动物{
public void eat(){
System.out.println("小鸡在吃")；//在父类Animal中输入eat方法
行重写
}
}对象类型转换：
type的基础数据可以转换成类型，转换类型高时可以自动转换，转换类型低时需要强制转换。类型也允许转换，仅限于java类层次图的一个分支，即父类和子类之间。在树枝上，离物体较近的那根向上，较远的那根向下。因此，对象的类型转换可以分为“向上转换”和“向下转换”。
公开课鸭展动物{
@覆盖
public void eat() {
system . out . println()；
}
公共void庸医(){
System.out.println(嘎嘎嘎嘎)；
}
公共静态void main(String[] args) {
动物a1=新动物()；//实例化过程
动物a2=新鸭()；//向上转换
a1 . eat()；
a2 . eat()；
//a2 . quak()；//移除注释会发生什么？
}
}向下转换：只能对指向子类对象的基类对象的引用执行。
公开课鸭展动物{
@覆盖
public void eat() {
system . out . println()；
}
公共void庸医(){
System.out.println(嘎嘎嘎嘎)；
}
公共静态void main(String[] args) {
动物a=新鸭()；//向上转换
鸭子b=(鸭子)a；//向下转换
a . eat()；
b . eat()；
b .嘎嘎()；
}
}Instanceof关键字：
of关键字用于确定左对象是否是右实例，并返回布尔数据。
Boolean=类的对象实例。同时也可以用来判断继承的子类的实例是否是父类的实现。
.
公共静态void main(String[] args) {
动物a=新鸭()；//向上转换
如果(一只鸭子){
((鸭)答)。嘎嘎()；
}
}
.这是java的三个特点。它们是什么？更多详情请关注我们的其他相关文章！
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。