面向对象

面向对象的程序设计具有封装性、继承性、多态性。
类的定义语法如下：

class 类名称{数据类型 属性(变量);...public 返回值的数据类型 方法名称(参数1，参数2...){程序语句;[return 表达式;]
}
}

定义类

class Book {String title;double price;public void getlnfo() {System.out.println("图书名称:" + title + ",价格" + price);}}

声明并实例化对象

类名称 对象名称 = new 类名称();

class Book {                             //定义一个类String title;double price;public void getlnfo() {                //此方法将由对象调用System.out.println("图书名称:" + title + ",价格" + price);}}
public class Test1_2 {public static void main(String args[]){Book bk = new Book();             //声明并实例化对象bk.title = "java开发";bk.price = 89.9;bk.getlnfo();                     //调用类中的getlnfo()方法}
}

堆内存：
保存每一个对象的属性内容，堆内存需要用关键字new才可以开辟(可以理解为只要有关键字new，不管在何种情况下，都表示要开辟新的堆内存空间)，如果一个对象没有对应的堆内存指向，将无法使用。
栈内存：
保存的是一块堆内存的地址数据，可以把它想象成一个int型变量(每一个 int型变量只能存放一个数值)，所以每一块栈内存只能够保留一块堆内存地址。

二者关系如下：

引用传递

public class Test1_2 {public static void main(String args[]){Book bookA = new Book();Book bookB = null ;   //注意这里没有使用new实例化bookA.title = "java开发";bookA.price = 89.9;bookB=bookA;     //引用传递，相当于BookA和BookB这两个栈内存同时指向同一块堆内存bookB.price = 60;  //所以BookB修改属性内容时，会直接影响BookA对象的内容bookA.getlnfo();}
}

我将它理解为创造多个不同名称的指针来指向同一个地址。

同理，声明并实例化的对象也可以进行引用传递。

public class Test1_3 {public static void main(String args[]){Book bookA = new Book();//声明并实例化Book bookB = new Book();//声明并实例化bookA.title = "java开发";bookA.price = 89.8;bookB.title = "JSP开发";bookB.price = 69.8;bookB=BookA;//引用传递bookB.price = 100.1;bookB.getlnfo();}
}

经过引用传递后bookB原来的堆内存里面的数据就没有对象指向了，该内存空间也就成为了垃圾空间。
在java中所有的垃圾都会不定期地被垃圾收集器(GC)回收，回收后会释放掉其所占用的空间。

封装性初步分析

使用private关键字封装，将类中的属性进行私有化操作。
封装后的属性只能在该类中被访问，除非定义相应的setter、getter方法。

class Book2{private String title;private double price;public void setTitle(String t){title = t;}public void setPrice(double p){if(p>0.0){                        //数据验证price = p;}}public String getTitle(){return title;}public double getPrice(){return price;}public void getInfo(){System.out.println("图书名称："+title+",价格："+price);}
}
public class Test1_4 {public static void main(String args[]){Book2 book = new Book2();book.setTitle("Java开发");book.setPrice(-89.9);book.getInfo();}
}

setter方法主要是设置内容：public void setTitle(String t)，有参；
getter方法主要是取得属性内容：public String getTitle()，无参；

构造方法

构造方法本身是一种特殊的方法，它只在新对象实例化的时候调用
定义原则：
方法名称与类名称相同，没有返回值类型声明，同时构造方法可以进行重载。

class Book3{public Book3(){              //构造方法System.out.println("**********");}
}
public class Test1_5 {public static void main(String args[]){Book3 book = null;book = new Book3();}
}

构造方法只有在使用关键字new实例化对象时才会被调用一次。

用构造方法为属性赋值

class Book3{private String title;private double price;public Book3(String t,double p){setTitle(t);setPrice(p);}public void setTitle(String t){title = t;}public void setPrice(double p){price = p;}public String getTitle(){return title;}public double getPrice(){return price;}public void getInfo(){System.out.println("图书名称："+title+",价格："+price);}
}
public class Test1_5 {public static void main(String args[]){Book3 book = new Book3("Java开发",69.8);book.getInfo();}
}

匿名对象

没有栈内存指向的堆内存空间，就是一个匿名对象。

class Book4{private String title;private double price;public Book4(String t,double p){title = t;price = p;}public void getInfo(){System.out.println("图书名称："+title+",价格："+price);}
}
public class Test1_6 {public static void main(String args[]){new Book4("Java开发",69.8).getInfo();     //匿名对象}
}

这里的匿名对象由于没有对应的栈内存指向，所以只能使用一次，一次过后就将成为垃圾，并等待GC回收释放。

简单Java类

基本开发要求：
1.类的名称必须存在意义；
2.类中所有的属性必须private封装，封装后的属性必须提供setter、getter；
3.类中可以提供任意多个构造方法，但是必须保留一个无参构造方法；
4.类中不允许出现任何输出语句，所有信息输出必须交给被调用处输出；
5.类中需要提供一个取得对象完整信息的方法，而且返回String型数据。

class Emp{private int empno;      //雇员编号private String ename;   //雇员姓名private String job;     //雇员职位private double sal;     //雇员工资private double comm;    //佣金public Emp(){           //明确一个无参构造方法}public Emp(int eno,String ena,String j,double s,double c){//有参构造empno = eno;             //为属性赋值ename = ena;job = j;sal = s;comm = c;}public void setEmpno(int e){   //设置属性内容empno = e;}public void setEname(String e){ename = e;}public void setJob(String j){job = j;}public void setSal(double s){sal = s;}public void setComm(double c){comm = c;}public int getEmpno() {           //取得属性内容return empno;}public String getEname(){return ename;}public  String getJob(){return job;}public double getSal(){return sal;}public double getComm(){return comm;}public String getInfo(){       //取得完整信息return "雇员编号："+empno+"\n"+ "雇员姓名："+ename+"\n"+"雇员职位："+job+"\n"+"基本工资："+sal+"\n"+"佣金："+comm;}
}
public class Test1_7 {public static void main(String args[]){Emp e =new Emp(7369,"SMITH","CLERK",800.0,1.0);   //实例化对象System.out.println(e.getInfo());             //取得对象信息}
}

数组

java中数组的基本概念：
数组指的就是一组相关变量的集合。

数组属于引用型数据。

声明并开辟数组：

数据类型 数组名称 [] = new 数据类型 [长度] ;
数据类型 [] 数组名称 = new 数据类型 [长度] ;

java为了方便数组的输出，提供了一个"数组名称.length"的属性，可以取得数组长度

数组动态初始化

public class Test1_8 {public static void main(String args[]){int data [] = new int [3];     //定义数组data[0] = 10;data[1] = 20;data[2] = 30;for(int x=0;x<data.length;x++){System.out.println(data[x]);}}
}

注意：不能直接使用未开辟空间的数组

数组也可以进行引用传递

public class Test1_9 {public static void main(String args[]){int data[] = new int [3];data[0] = 10;data[1] = 20;data[2] = 30;int temp[] = data;  //数组的引用传递temp[0] = 99;for(int x=0;x<data.length;x++) {System.out.println(data[x]);}}
}

数组静态初始化

格式：
1.简化形式

数据类型 数组名称 [] ={值,值,...};

2.完整形式

数据类型 数组名称 [] = new 数据类型 [] {值,值,...};

public class Test1_1_1 {public static void main(String args[]){int data[] = new int[] {1,2,3,4,5};for(int x=0;x<data.length;x++){System.out.println(data[x]);}}
}

二维数组

动态初始化：数据类型 数组名称[][] = new 数据类型[行数][列数];
静态初始化：数据类型 数组名称[][] = new 数据类型[][] {{值,...,值},{值,...,值}}

所谓的二维数组其实就是将多个一维数组变为一个大数组，并且为每个一维数组设置一个行号。

public class Test1_1_2 {public static void main(String args[]){int data[][] = new int [][]{{1,2,3},{4,5,6},{7,8,9}};for(int x=0;x<data.length;x++){for(int y=0;y<data.length;y++){System.out.print(data[x][y]+"\t");}System.out.println();}}
}

数组作为方法参数的传递

public class Test1_1_3 {public static void main(String args[]){int data[] = new int[]{1,2,3};change(data);for(int x=0;x<data.length;x++){System.out.println(data[x]);}}public static void change(int temp[]){for(int x=0;x<temp.length;x++){temp[x]=temp[x]*2;}}
}

既然有匿名对象，那当然也有匿名数组。

数组操作方法

数组复制

数组复制可以将一个数组的部分内容复制到另外一个数组之中。

System.arraycopy(数组名称,源数组复制开始索引,目标数组名称,目标数组复制开始索引,长度)

public class Test1_1_4 {public static void main(String args[]){int dataA[] = new int[]{1,2,3,4,5,6,7,8};int dataB[] = new int[]{11,22,33,44,55,66,77,88};System.arraycopy(dataA,4,dataB,2,3);print(dataB);}public static void print(int temp[]){for(int x=0;x<temp.length;x++){System.out.print(temp[x]+"、");}System.out.println();}
}
结果为：11、22、5、6、7、66、77、88、

数组排序

数组排序可以按照由小到大的顺序对基本数据类型进行排序。
其定义如下：

java.util.Arrays.sort(数组名称);

public class Test1_1_5 {public static void main(String args[]){int data[] = new int[]{3,6,1,2,8,0};java.util.Arrays.sort(data);print(data);}public static void print(int temp[]){for(int x=0;x<temp.length;x++){System.out.print(temp[x]+"、");}System.out.println();}
}

Java学习总结：4相关推荐

Java学习路线图，如何学习Java事半功倍？
作为一个初学者想掌握Java并不是很容易,Java本身是具有一定难度的,虽然说兴趣这东西可以让我们学习不累,但是有多少人学习是因为兴趣,或者有多少人知道自己的兴趣在哪?所以我很明确的告诉你学习这事本来 ...
Java学习必不可少的网站，快收藏起来
java技术在IT互联网行业的发展前景一直在提升,越来越多的人都在学习java技术,今天小编来给大家提供一些学习Java的网站集合,希望能够帮助到正在学习java技术的同学. Java学习必不可少的网 ...
分享五款java学习辅助工具，总有你用的上的~
想要学好java技术,除了自身的努力,辅助工具也不缺少,辅助工具可以帮助大家在今后的工作中可以提高工作效率,下面小编就来分享五款java学习辅助工具,总有你用的上的~ 五款java学习辅助工具: 1. ...
Java学习从入门到精通的学习建议
想要学好java技术,首先打好基础很重要,不论学什么基础都是重中之重,学习Java更是如此.如:基础语法.核心类库.面向对象编程.异常.集合.IO流等基础如果学不好,那么后边更深入的语法也不容易学会. ...
java学习笔记11--Annotation
java学习笔记11--Annotation Annotation:在JDK1.5之后增加的一个新特性,这种特性被称为元数据特性,在JDK1.5之后称为注释,即:使用注释的方式加入一些程序的信息. j ...
java学习笔记13--反射机制与动态代理
本文地址:http://www.cnblogs.com/archimedes/p/java-study-note13.html,转载请注明源地址. Java的反射机制在Java运行时环境中,对于任意 ...
JAVA学习资源网站
中文java技术网--http://www.cn-java.com/ 灰狐动力(http://www.huihoo.com/)-- 该站点有许多的开源的项目的介绍和学习,涉及操作系统,数据库等许多方向 ...
我的WEB之路（一）-2.JAVA学习路线
第一阶段:针对性夯实JAVA基础课程名称核心要点完成目标 Java基础入门搭建Java开发和运行环境等,IDE工具的学习和使用,Java语言基础,数据类型,运算符,条件和循环,数组使用等,Ja ...
准备写java学习笔记
准备写java学习笔记 java int 转载于:https://blog.51cto.com/cryingcloud/1975267
Java学习笔记--StringTokenizer的使用
2019独角兽企业重金招聘Python工程师标准>>> Java Tips: 使用Pattern.split替代String.split String.split方法很常用,用于切割 ...

Java学习总结：4