一、面向对象和面向过程的区别
二、类和对象
对象:具体的事物,具体的实体,模板下的产品
类:对对象向上抽取出像、公共的部分,形成类,类是抽象的是一个模板
三、面向对象的三个阶段
1.面向对象分析(OOA)
对象抽取一个类
类中含有:
动词---->动态特性—>方法
名词---->静态属性—>属性
2.面向对象设计(OOD)
创建类:
创建对象:为所创建的对象开辟空间,并且初始化赋值属性
3.面向对象编程(OOP)
四、局部变量与成员变量
1.位置:
局部变量:方法中定义的变量(必须进行初始化)
成员变量:类中方法外定义的变量(栈中)
2、作用范围
局部变量:只在当前方法中只用
成员变量:当前类的所有方法中
3.是否有默认值
局部变量:无
成员变量:有
基本类型 | 默认值 |
---|---|
boolean | False |
char | ‘\u0000’ |
byte | (byte)0 |
short | (short)0 |
int | 0 |
long | 0L |
float | 0.0f |
double | 0.0d |
五、构造器
1、构造方法的调用
new 关键字就是在进行构造方法的调用,没有构造器时系统将会自动默认分配构造器,但当自定义构造器之后,系统将不会再分配构造器
2、构造器的作用
为对象的属性赋值,但不能在构造器中赋值,赋值后所有属性值都会一样,只要保证空构造器的存在即可
3、构造器与方法的区别
(1)构造器的结构
(修饰符) 构造器的名字(){
}
(2)区别
a.没有return值
b.没有返回值类型
c.构造器的名字必须和类名相同
4.构造器的重载
(1)一般保证构造器的存在,空构造器中一般不会进行属性的赋值操作
(2) 一般我们会重载构造器,在重载的构造器中进行属性的赋值
(3)在重载构造器以后,空构造器没有写,系统不会再进行默认分配构造器了,需要加入空构造器
(4)属性名和形参名重名是会出现就近原则解决办法
(5)再要表示对象的属性前加上this. this. 代表你创建的那个对象
public class Person {
//属性
String name;
int age;
int weight;
//构造器:没有任何参数的构造器造作空参构造器
public Person(){
}
public Person(String name,int age,double weight){
this.name=name ;
this age=age;
this weight=weight;
}
六、内存分析
1.
public class Person{
//成员变量
int ad;
int age;
public static void main(String args[])
Person p1=new Person();
System.out.println(p1.age);
}
内存分析图
2.
public class Person1 {
int id;
int age;
String school;
public Person1(int a,int b,String c){
id=a;
age=b;
school=c;
}
public static void main(String[] args) {
Person1 p=new Person1(1,20,"china");
}
}
七、this关键字的使用
1.修饰属性
当属性名和形参名发生重名时或者属性和局部变量发生重名时,会发生就近原则,直接使用变量名字指的是形参或者局部变量,要表示属性是需用this修饰,不发生重名问题实际上访问属性也有this只是省略了。
(this指代当前使用和构造的对象)
public class Person {
//成员变量
int age;
String name;
double weight;
//空构造器
public Person(){
}
//有参构造器
public Person(int age,String name,double weight){
this.age=age;
this.name=name;
this.weight=weight;
}
public void eat(){
int age=10;
System.out.println(age);//就近原则 out:10;
System.out.println(this.age);//out:19;指代的是属性的age
System.out.println("I like eat");
}
}
2.this修饰方法
在同一个类中,方法可以互相调用,this.可以省略
public void play(){
this.eat();//this.可以省略;
System.out.println("踢足球");
System.out.println("跑步");
}
private void eat(){
System.out.println("吃饭");
}
}
3.this可以修饰构造器
同一类中的构造器可以相互用this调用,注意:this修饰构造器必须放在第一行
public Person(int age,String name,double weight){
this(age,name);//this修饰构造器
this.weight=weight;
}
public Person(int age,String name){
this(age);//this修饰构造器
this.name=name;
}
public Person(int age){
this.age=age;
}
八、static关键字
static可以修饰:属性,方法,内部类,代码块
1.static修饰属性
public class static {
//成员变量
int id;
static int sid;
public static void main(String[] args) {
stati t1=new stati();
t1.id=10;
t1.sid=10;
stati t2=new stati();
t2.id=20;
t2.sid=20;
stati t3=new stati();
t3.id=30;
t3.sid=30;
System.out.println("t1.id\tt2.id\tt3.id");
System.out.println("t1.sid\tt2.sid\tt3.sid");
官方的推荐的访问模式:可以通过类名.属性名的方式去访问
stati.sid=100;
System.out.println(sid);
static修饰属性总结
(1)在类的加载的时候一起加载入方法区中的静态域中
(2)先于对象存在
(3)访问方式 对象名.属性名或者类名.属性名
static使用情景
当前的方法多次调用这个变量,且改变量不改变
public class XuptSchool {
String name;
int age;
static String school;
public static void main(String[] args) {
XuptSchool.school="xupt";
XuptSchool s1=new XuptSchool();
s1.name="lili";
s1.age=19;
XuptSchool s2=new XuptSchool();
s2.name="sara";
s2.age=20;
System.out.println(s1.school);
System.out.println(s2.school);
System.out.println(s1.age);
System.out.println(s1.name);
}
}
2.static修饰方法
(1)普通方法
既可以访问静态属性也可以访问非静态属性
(2)静态方法
public和static都为修饰符没有先后顺序的关系
被static修饰的方法在加载类的时候会首先加载这个方法,先于对象加载,被所有对象共享
static public void(){
}
静态方法不能访问非静态方法
静态方法只能访问静态属性
静态方法中不能使用this关键字(先于对象的存在)
(3)调用
a.非静态方法
对象名.方法名
b.静态方法
类名.方法名
对象名.方法名
public class Demo {
int id;
static int sid;
public void a(){
//在普通的方法中既可以访问静态属性也可以访问非静态属性
System.out.println(id);
System.out.println(sid);
}
//1.static和public都为修饰符,没有先后顺序关系
//2.被static修饰的方法在加载类的时候会优先被加载,先于对象加载,被所有该类的对象共享
static public void b(){
//1.a();在静态方法中不能访问非静态的方法
//2.System.out.println(id);在静态方法中不能访问非静态的属性,先于对象存在
//3,this.id在静态方法中不能使用this关键字
System.out.println(sid);
}
public static void main(String[] args) {
//非静态方法可以用对象名.方法名调用;
Demo d=new Demo();
d.a();
//静态方法可以用对象名.方法或者类名.方法调用
Demo.b();
d.b();
}
}
3.static修饰代码块
类的组成:
属性、方法、构造器、代码块、内部类
代码块的分类:普通块,静态块、构造块、同步块
(1)普通块
定义在方法中。其中变量右局限性,只能在代码块中使用
public void a(){
//普通代码块(方法中)
System.out.println(a);
System.out.println(sa);
{
int num=1;
System.out.println(num);
System.out.println("这是一个普通块");
}
//if(num){范围在括号当中
}
(2)静态块
定义在方法外,用static修饰,只能访问静态属性和静态方法
static{//静态块
System.out.println("这是一个静态块");
//只能访问静态属性和方法
System.out.println(sa);
b();
}
(3)构造块
定义在方法外的代码块
{//代码构造块(方法外)
System.out.println("这是构造块");
}
4.执行的顺序
a.先执行静态块,只在类加载是执行一次,一般用于工厂,数据库的初始化信息放入静态块,一般用于执行一些全局性的初始化操作
b.在执行构造块
c.执行构造器
d.执行方法中的普通块
public class Test {
//属性
int a;
static int sa;
//方法
public void a(){
//普通代码块(方法中)
System.out.println(a);
System.out.println(sa);
{
int num=1;
System.out.println(num);
System.out.println("这是一个普通块");
}
//if(num){范围在括号当中
}
public static void b(){
}
{//代码构造块(方法外)
System.out.println("这是构造块");
}
static{//静态块
System.out.println("这是一个静态块");
//只能访问静态属性和方法
System.out.println(sa);
b();
}
//有参构造器
public Test(int a){
this.a=a;//构造器为成员变量赋值
}
//空构造器
public Test(){
System.out.println("这是一个空构造器");
}
public static void main(String[] args) {
Test s=new Test();
s.a();
Test t=new Test();
t.a();
}
}
九、包
1.包的作用
为了解决重名问题(实际上对应着盘符上的目录)
解决权限问题
2.包名定义
(1)全部为小写
(2)中间用.隔开
(3)一般为公司域名倒着写。例:com.jd com.albb
(4)加上模块的名字
com.jd.login com.jd.register
(5)不能使用系统的关键字。nul,con,com1,com9;
(6)包声明的位置一般都在非注释性代码的第一行
3.导包问题
(1)使用不同包下的类需要导包:import java.util.Date
(2)在导包后想用其他的包下同名的包,需自己手动写所在的包
(3)同一个包下的类想使用不需要导包,可以直接使用
(4)在java.lang包下的类直接使用无需导包
(5)导包快捷键:alt+enter
(6)java.util意为将util下所有类都都直接导入
5.在java中导包没有包含与被包含的关系
import static java.lang.Math.;
导入Java.lang下的Math类中的所有静态的内容
package com.twx;
//非静态导入
import static java.lang.Math.*;
//导入java.lang下的Math类中所有的静态类容
import java.util.Random;
public class Person {
public static void main(String[] args) {
System.out.println(new Random());
System.out.println(PI);
System.out.println(round(3.2));
}
//在静态导入后同一个方法中右相同的类的时候,优先走自己定义的方法
public static int round(double a){
return 1000;
}
}