JAVA自学看什么书好

1、《Head First Java》：适合初学者，与国内计算机类教材果然有很大差异。生动的例子、细致地讲述、风趣的配图，各种难度不同的练习，很棒。

2、《实战Java程序设计》：这是一本既注重实战，同时也注重底层“内功”（内存分析、JVM底层、数据结构）训练的书，本书能帮 助初学者打通Java编程“任督二脉”。

另关于自学，先提几条建议，望采纳！

找一个行业当中的师傅进行规划和指导。

每天规划好学习时间，不要中断。

先掌握了解知识体系后编写项目，边抓细节。

不能只看书，学习编程本就是枯燥无味，也可以看一下视频课提高下自己的兴趣！

我们免费的视频课在B站可观看，有兴趣可以了解一下！搜索我们官方“尚学堂”即可

另附上学习的路线，希望对你有所帮助吧！

如需更多的学习资料，私聊回复“java”即可获取~

望采纳~

Java是一种面向对象的程序开发语言，准确的理解java的面向对象才能更好更快地掌握JAVA的编程思想和方法，本文昌平北大青鸟java培训专家为大家介绍java面向对象，帮助大家更好的理解java。

1、什么是对象？

首先要说明一点，对象不是java的，事实上他只是一种概念，一种用于解决问题的程序设计的思想方法。要理解对象就必须得要和面向对象结合起来。在面向对象中把某一类事物所共有的属性和行为抽象出来之后就形成了一个类。而类的一个实际的例子就叫做对象。所以从上可以看出类和对象之间存在着这样一种关系：类是具有共同的属性名称和行为的一组对象的抽象，而对象则是一个类的真实的例子。

类是现实世界或思维世界中的实体在计算机中的反映，它将数据以及这些数据上的 *** 作封装在一起。

类描述了具有相同特性（数据元素、状态变量）和行为（对数据元素、状态变量的 *** 作）的对象集合，如果我需要某个具有一定功能的工具，那么我可自定义这个类，里面有我需要的数据，还有让这个类提供的功能。

对象是具有类类型的变量。类和对象是面向对象编程技术中的最基本的概念。类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类是用于创建对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的软件模板。

JAVA是一种面向对象的程序设计语言，对象是由类抽象出来的，所有的问题都是通过对象来处理，对象可以 *** 作类的属性和方法来解决问题，所以了解对象的产生、 *** 作和消亡是十分必要的。对象可以认为是在一类事物中抽象出某一个特例，通过这个特例来处理这类事物出现的问题，在Java语言中通过new *** 作符来创建对象。

2、对象和对象引用

如下表达式：Aa1=newA;它代表A是类，a1是引用，a1不是对象，newA才是对象，a1引用指向newA这个对象。

在JAVA里，“=”不能被看成是一个赋值语句，它不是在把一个对象赋给另外一个对象，它的执行过程实质上是将右边对象的地址传给了左边的引用，使得左边的引用指向了右边的对象。JAVA表面上看起来没有指针，但它的引用其实质就是一个指针，引用里面存放的并不是对象，而是该对象的地址，使得该引用指向了对象。在JAVA里，“=”语句不应该被翻译成赋值语句，因为它所执行的确实不是一个赋值的过程，而是一个传地址的过程，被译成赋值语句会造成很多误解，译得不准确。

再如：Aa2;它代表A是类，a2是引用，a2不是对象，a2所指向的对象为空null;

再如：a2=a1;它代表，a2是引用，a1也是引用，a1所指向的对象的地址传给了a2(传址），使得a2和a1指向了同一对象。

综上所述，可以简单的记为，在初始化时，“=”语句左边的是引用，右边new出来的是对象。

在后面的左右都是引用的“=”语句时，左右的引用同时指向了右边引用所指向的对象。再所谓实例，其实就是对象的同义词。

3、Java继承性分析

继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。继承可以理解为一个对象从另一个对象获取属性的过程。如果类A是类B的父类，而类B是类C的父类，我们也称C是A的子类，类C是从类A继承而来的。在Java中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类。继承中最常使用的两个关键字是extends（IS-A，是一个什么东西）和implements（Has-A，有一个什么功能）。这两个关键字的使用决定了一个对象和另一个对象是否是IS-A(是一个)关系。

昌平北大青鸟java培训专家提醒大家，通过使用这两个关键字，我们能实现一个对象获取另一个对象的属性。所有Java的类均是由javalangObject类继承而来的，所以Object是所有类的祖先类，而除了Object外，所有类必须有一个父类。通过extends关键字可以申明一个类是继承另外一个类而来的，通过使用关键字extends，子类可以继承父类所有的方法和属性，但是无法使用private(私有)的方法和属性。我们通过使用instanceof *** 作符，能够确定子类IS-A父类。

自己写的，也才学不容易还望采纳

import javautil;

abstract class Shape{

final static double PI=314;

public abstract double getPerimeter();

public abstract double getArea();

public static double sumAllArea(Shape []shapes) {

double x=0;

for(Shape e:shapes) {

x+=egetArea();

}

return x;

}

public static double sumAllPerimeter(Shape []shapes) {

double y=0;

for(Shape e:shapes) {

y+=egetPerimeter();

}

return y;

}

}

class Rectangle extends Shape{

private int width;

private int length;

public double getPerimeter() {

return 2(width+length);

}

public double getArea() {

return widthlength;

}

public Rectangle(int width,int length) {

thiswidth=width;

thislength=length;

}

@Override

public String toString() {

return "Rectangle [width=" + width + ", length=" + length + "]";

}

}

class Circle extends Shape{

private int radius;

public double getPerimeter() {

// TODO Auto-generated method stub

return 2PIradius;

}

public double getArea() {

// TODO Auto-generated method stub

return PIradiusradius;

}

public Circle(int radius) {

thisradius=radius;

}

@Override

public String toString() {

return "Circle [radius=" + radius + "]";

}

}

public class Main{

public static void main(String[] args) {

Scanner in=new Scanner(Systemin);

int n;

n=innextInt();

Shape shapes[]=new Shape[n];

for(int i=0;i<n;i++) {

String s=innext();

switch(s) {

case "rect":

int width,length;

width=innextInt();

length=innextInt();

shapes[i]=new Rectangle(width, length);

break;

case "cir":

int radius;

radius=innextInt();

shapes[i]=new Circle(radius);

break;

}

}

Systemoutprintln(ShapesumAllPerimeter(shapes));

Systemoutprintln(ShapesumAllArea(shapes));

Systemoutprintln(ArraystoString(shapes));

for(int i=0;i<n;i++) {

Systemoutprintln(shapes[i]getClass()+","+shapes[i]getClass()getSuperclass());

}

}

}

　java语言中有三个典型的面向对象的特性：封装性、继承性和多态性。1． 封装性

java语言中，对象就是对一组变量和相关方法的封装，其中变量表明了对象的状态，方法表明了对象具有的行为。通过对象的封装，实现了模块化和信息隐藏。通过对类的成员施以一定的访问权限，实现了类中成员的信息隐藏。

◇ java类中的限定词

java语言中有四种不同的限定词，提供了四种不同的访问权限。

1） private

类中限定为private的成员，只能被这个类本身访问。

如果一个类的构造方法声明为private,则其它类不能生成该类的一个实例。

2） default

类中不加任何访问权限限定的成员属于缺省的（default）访问状态：friend，可以被这个类本身和同一个包中的类所访问。

3） protected

类中限定为protected的成员，可以被这个类本身、它的子类（包括同一个包中以及不同包中的子类）和同一个包中的所有其他的类访问。

4） public

类中限定为public的成员，可以被所有的类访问。

表3-1　java中类的限定词的作用范围比较

同一个类

同一个包

不同包的子类

不同包非子类

private

default

protected

public

2． 继承性

通过继承实现代码复用。Java中所有的类都是通过直接或间接地继承javalangObject类得到的。继承而得到的类称为子类，被继承的类称为父类。子类不能继承父类中访问权限为private的成员变量和方法。子类可以重写父类的方法，及命名与父类同名的成员变量。但Java不支持多重继承，即一个类从多个超类派生的能力。

◇ 成员变量的隐藏和方法的重写

子类通过隐藏父类的成员变量和重写父类的方法，可以把父类的状态和行为改变为自身的状态和行为。

例如：

class SuperClass{

int x; …

void setX( ){ x=0; } …

}

class SubClass extends SuperClass{

int x; //隐藏了父类的变量x

…

void setX( ) { //重写了父类的方法 setX()

x=5; } …

}

注意：子类中重写的方法和父类中被重写的方法要具有相同的名字，相同的参数表和相同的返回类型，只是函数体不同。

◇ super

java中通过super来实现对父类成员的访问，super用来引用当前对象的父类。Super 的使用有三种情况：

1）访问父类被隐藏的成员变量，如：

supervariable;

2）调用父类中被重写的方法，如：

superMethod([paramlist]);

3）调用父类的构造函数，如：

super([paramlist]);例3-5

import javaio;

class SuperClass{

int x;

SuperClass( ) {

　x=3;

　Systemoutprintln("in SuperClass : x=" +x);

}

　void doSomething( ) {

　Systemoutprintln("in SuperClassdoSomething()");

}

}

class SubClass extends SuperClass {

int x;

SubClass( ) {

　super( );//调用父类的构造方法

　x=5;//super( ) 要放在方法中的第一句

　Systemoutprintln("in SubClass :x="+x);

}

　void doSomething( ) {

　superdoSomething( ); //调用父类的方法

　Systemoutprintln("in SubClassdoSomething()");

　Systemoutprintln("superx="+superx+" subx="+x);

}

}

public class Inheritance {

　public static void main(String args[]) {

　SubClass subC=new SubClass();

　subCdoSomething();

}

}3． 多态性

在java语言中，多态性体现在两个方面：由方法重载实现的静态多态性（编译时多态）和方法重写实现的动态多态性（运行时多态）。

1） 编译时多态

在编译阶段，具体调用哪个被重载的方法，编译器会根据参数的不同来静态确定调用相应的方法。

2） 运行时多态

由于子类继承了父类所有的属性（私有的除外），所以子类对象可以作为父类对象使用。程序中凡是使用父类对象的地方，都可以用子类对象来代替。一个对象可以通过引用子类的实例来调用子类的方法。

◇ 重写方法的调用原则：java运行时系统根据调用该方法的实例，来决定调用哪个方法。对子类的一个实例，如果子类重写了父类的方法，则运行时系统调用子类的方法；如果子类继承了父类的方法（未重写），则运行时系统调用父类的方法。

在例3-6中，父类对象a引用的是子类的实例，所以，java运行时调用子类B的callme方法。例3-6

import javaio;

class A{

　void callme( ) {

Systemoutprintln("Inside A's callme()method");

　}

}

class B extends A{

　void callme( ) {

Systemoutprintln("Inside B's callme() Method");

　}

}

public class Dispatch{

　public static void main(String args[]) {

A a=new B();

acallme( );

　}

}

◇ 方法重写时应遵循的原则：

1）改写后的方法不能比被重写的方法有更严格的访问权限（可以相同）。

2）改写后的方法不能比重写的方法产生更多的例外。

4． 其它

◇ final 关键字

final 关键字可以修饰类、类的成员变量和成员方法，但final 的作用不同。

1） final 修饰成员变量：

final修饰变量,则成为常量，例如

final type variableName;

修饰成员变量时，定义时同时给出初始值，且以后不能被修改，而修饰局部变量时不做要求。

2） final 修饰成员方法：

final修饰方法，则该方法不能被子类重写

final returnType methodName(paramList){

…

}3） final 类：

final修饰类，则类不能被继承

final class finalClassName{

…

}

◇ 实例成员和类成员

用static 关键字可以声明类变量和类方法，其格式如下：

static type classVar;

static returnType classMethod({paramlist}) {

…

}

　如果在声明时不用static 关键字修饰，则声明为实例变量和实例方法。

1） 实例变量和类变量

每个对象的实例变量都分配内存，通过该对象来访问这些实例变量，不同的实例变量是不同的。

类变量仅在生成第一个对象时分配内存，所有实例对象共享同一个类变量，每个实例对象对类变量的改变都会影响到其它的实例对象。类变量可通过类名直接访问，无需先生成一个实例对象，也可以通过实例对象访问类变量。

2） 实例方法和类方法

实例方法可以对当前对象的实例变量进行 *** 作，也可以对类变量进行 *** 作，实例方法由实例对象调用。

但类方法不能访问实例变量，只能访问类变量。类方法可以由类名直接调用，也可由实例对象进行调用。类方法中不能使用this或super关键字。

例3-7 是关于实例成员和类成员的例子。

例3-7

class Member {

static int classVar;

int instanceVar;

static void setClassVar(int i) {

　classVar=i;

　// instanceVar=i; // 类方法不能访问实例变量

}

static int getClassVar()

　{ return classVar; }

void setInstanceVar(int i)

　{ classVar=i; //实例方法不但可以访问类变量，也可以实例变量

　instanceVar=i; }

　int getInstanceVar( )

　{ return instanceVar; }

}

public class MemberTest{

　public static void main(String args[]) {

Member m1=new member();

Member m2=new member();

m1setClassVar(1);

m2setClassVar(2);

Systemoutprintln("m1classVar="+m1getClassVar()+"

m2ClassVar="+m2getClassVar());

m1setInstanceVar(11);

m2setInstanceVar(22);

Systemoutprintln("m1InstanceVar="+m1getInstanceVar

()+" m2InstanceVar="+m2getInstanceVar());

　}

}

◇ 类javalangObject

类javalangObject处于java开发环境的类层次的根部，其它所有的类都是直接或间接地继承了此类。该类定义了一些最基本的状态和行为。下面，我们介绍一些常用的方法。

equals() ：比较两个对象(引用)是否相同。

getClass()：返回对象运行时所对应的类的表示，从而可得到相应的信息。

toString()：用来返回对象的字符串表示。

finalize()：用于在垃圾收集前清除对象。

notify(),notifyAll(),wait()：用于多线程处理中的同步。

以上就是关于JAVA自学看什么书好全部的内容，包括:JAVA自学看什么书好、如何理解Java面向对象、7-1 jmu-Java-03面向对象基础-04-形状-继承（15 分）等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！